diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml index fecdbf7a52..e5e8b5b31f 100644 --- a/.github/workflows/main.yml +++ b/.github/workflows/main.yml @@ -47,18 +47,12 @@ jobs: cmake_config: -DMATERIALX_BUILD_SHARED_LIBS=ON static_analysis: ON - - name: Linux_Clang_13_Python39 - os: ubuntu-22.04 - compiler: clang - compiler_version: "13" - python: 3.9 - test_render: ON - - name: Linux_Clang_14_Python311 os: ubuntu-22.04 compiler: clang compiler_version: "14" python: 3.11 + test_render: ON clang_format: ON - name: Linux_Clang_14_DynamicAnalysis @@ -89,6 +83,13 @@ jobs: python: 3.11 test_shaders: ON + - name: iOS_Xcode_14 + os: macos-13 + compiler: xcode + compiler_version: "14.3" + python: None + cmake_config: -DMATERIALX_BUILD_IOS=ON -DCMAKE_OSX_SYSROOT=`xcrun --sdk iphoneos --show-sdk-path` -DCMAKE_OSX_ARCHITECTURES=arm64 + - name: Windows_VS2019_Win32_Python37 os: windows-2019 architecture: x86 diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml new file mode 100644 index 0000000000..dddfefb9a4 --- /dev/null +++ b/.github/workflows/python.yml @@ -0,0 +1,130 @@ +name: python + +on: + push: + paths-ignore: + - '**.md' + pull_request: + paths-ignore: + - '**.md' + workflow_dispatch: + +jobs: + # Generate the sdist first. We'll use it to create the wheels. + # https://packaging.python.org/en/latest/flow#the-source-distribution-sdist + sdist: + name: Generate Source Distribution + runs-on: ubuntu-latest + outputs: + sdist_filename: ${{ steps.generate.outputs.filename }} + + steps: + - name: Sync Repository + uses: actions/checkout@v3 + + - name: Install Python ${{ matrix.python }} + uses: actions/setup-python@v4 + with: + python-version: 3.11 + + - name: Install Build Command + run: python -m pip install build + + - name: Generate Sdist + id: generate + run: | + python -m build -s . --outdir dist + echo "filename=$(ls dist)" >> "$GITHUB_OUTPUT" + + - name: Upload Sdist + uses: actions/upload-artifact@v3 + with: + name: MaterialX_Python_Source_Distribution + path: ./dist/*.tar.gz + + # Create the wheels. It'll use the sdist to confirm that we can compile MaterialX from the sdist. + # https://packaging.python.org/en/latest/flow#the-built-distributions-wheels + wheels: + name: Generate Wheel + runs-on: ${{ matrix.os }} + needs: ['sdist'] + strategy: + fail-fast: false + matrix: + python-version: ['37', '38', '39', '310', '311'] + os: ['ubuntu-latest', 'macos-latest', 'windows-latest'] + + steps: + - name: Download Sdist + uses: actions/download-artifact@v3 + with: + name: MaterialX_Python_Source_Distribution + path: sdist + + - name: Build Wheel + # https://cibuildwheel.readthedocs.io/en/stable/ + uses: pypa/cibuildwheel@v2.12.1 + with: + # Build from the sdist. We want to make sure it's valid and works as expected. + package-dir: ${{ github.workspace }}/sdist/${{ needs.sdist.outputs.sdist_filename }} + output-dir: wheels + env: + CIBW_BUILD: 'cp${{ matrix.python-version }}-*' + CIBW_SKIP: '*musllinux*' + CIBW_ARCHS: 'auto64' + # https://github.com/pypa/manylinux + # manylinux2014 is CentOS 7 based. Which means GCC 10 and glibc 2.17. + CIBW_MANYLINUX_X86_64_IMAGE: manylinux2014 + CIBW_BEFORE_ALL_LINUX: yum install -y libXt-devel + CIBW_BEFORE_ALL_MACOS: sudo xcode-select -switch /Applications/Xcode_13.4.app + CIBW_BUILD_VERBOSITY: 1 + CIBW_ENVIRONMENT: CMAKE_BUILD_PARALLEL_LEVEL=2 + # CIBW_BUILD_FRONTEND: build # https://github.com/pypa/build + MACOSX_DEPLOYMENT_TARGET: '10.15' + + - name: Upload Wheel + uses: actions/upload-artifact@v3 + with: + name: MaterialX_Python_Wheels + path: ./wheels/*.whl + + test: + name: Test Wheel + needs: ['wheels'] + runs-on: ${{ matrix.os }} + strategy: + fail-fast: false + matrix: + python-version: ['3.7', '3.8', '3.9', '3.10', '3.11'] + os: ['ubuntu-latest', 'macos-latest', 'windows-latest'] + + steps: + - uses: actions/checkout@v3 + + - uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python-version }} + + - name: Download Wheels + uses: actions/download-artifact@v3 + with: + name: MaterialX_Python_Wheels + path: wheels + + - name: Install Wheel + run: python -m pip install MaterialX --find-links wheels --no-index + + - name: Python Tests + shell: bash + run: | + set -e + python python/MaterialXTest/main.py + python python/MaterialXTest/genshader.py + python python/Scripts/mxformat.py ./resources/Materials/TestSuite/stdlib/upgrade --yes --upgrade + python python/Scripts/mxvalidate.py ./resources/Materials/Examples/StandardSurface/standard_surface_marble_solid.mtlx --stdlib --verbose + python python/Scripts/mxdoc.py --docType md ./libraries/pbrlib/pbrlib_defs.mtlx + python python/Scripts/mxdoc.py --docType html ./libraries/bxdf/standard_surface.mtlx + python python/Scripts/generateshader.py ./resources/Materials/Examples/StandardSurface --target glsl + python python/Scripts/generateshader.py ./resources/Materials/Examples/StandardSurface --target osl + python python/Scripts/generateshader.py ./resources/Materials/Examples/StandardSurface --target mdl + python python/Scripts/generateshader.py ./resources/Materials/Examples/StandardSurface --target msl diff --git a/.gitignore b/.gitignore index 378eac25d3..9d0b71a3c7 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,2 @@ build +dist diff --git a/CHANGELOG.md b/CHANGELOG.md index a27b8d124c..b65fdb32d4 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,35 @@ ## [1.38.8] - Development +### Added +- Added a broad set of new pattern nodes to MaterialX, including [Circle, Hexagon, Cloverleaf, Line, Grid, Crosshatch](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1411), [Checkerboard](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1328), [Random Color, Random Float](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1330), [Triangle Wave](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1334), [Integer Floor, Integer Ceiling](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1362), and [Distance](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1333). +- Added support for [MaterialX builds on iOS](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1435). +- Added support for [drag-and-drop import](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1482) of MaterialX files in the [Web Viewer](https://academysoftwarefoundation.github.io/MaterialX/). +- Added generation of [MaterialX Python wheels](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1317) in GitHub Actions, enabling the distribution of MaterialX Python packages through PyPI. +- Added support for the [lin_displayp3 and srgb_displayp3](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1368) colorspaces in shader generation. +- Added support for the [blackbody PBR node](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1367) in shader generation. +- Added support for [displacement](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1396) in MDL generation. +- Added version details to [shared libraries](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1447) on Windows. +- Added a [MacOS 13](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1375) build to GitHub Actions. + +### Changed +- Raised the minimum C++ version for MaterialX builds to [C++14](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1340). +- Upgraded the [PyBind11 library](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1343) to version 2.10.4, raising the minimum Python version to 3.6, and enabling support for Python versions 3.11 and beyond. +- Improved the performance and convergence of [GGX importance sampling](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1390) in GLSL generation, leveraging insights from the HPG 2023 paper by Jonathan Dupuy and Anis Benyoub. +- Improved [property panel display](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1346) in the MaterialX Graph Editor. +- Improved [node spacing](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1476) in the MaterialX Graph Editor. +- Improved the robustness of [MaterialX unit tests](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1370) with respect to the current working directory. +- Simplified the handling of [default colors](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1452) in GLSL generation, removing dynamic branches on texture size. +- Simplified the definitions of the [default color transforms](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1352), implementing them as language-independent MaterialX graphs. +- Moved the MaterialX specification to [public Markdown files in GitHub](https://github.com/AcademySoftwareFoundation/MaterialX/tree/main/documents/Specification), enabling direct contributions from the community. + +### Fixed +- Fixed brightness artifacts in the [triplanar projection node](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1350). +- Aligned default values for [conductor_bsdf](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1379) with the MaterialX specification. +- Fixed [volume mixing](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1395) in MDL generation. +- Fixed a bug to improve [shader generation determinism](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1376). +- Fixed a bug to improve the [consistency of auto layout](https://github.com/AcademySoftwareFoundation/MaterialX/pull/1389) in the MaterialX Graph Editor. + ## [1.38.7] - 2023-04-21 ### Added diff --git a/CMakeLists.txt b/CMakeLists.txt index a5624f0a64..58dfe85aed 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -31,7 +31,7 @@ if (MATERIALX_BUILD_JS) endif() endif() -project(MaterialX) +project(MaterialX VERSION ${MATERIALX_LIBRARY_VERSION}) option(MATERIALX_BUILD_PYTHON "Build the MaterialX Python package from C++ bindings. Requires Python 3.6 or greater." OFF) option(MATERIALX_BUILD_VIEWER "Build the MaterialX Viewer." OFF) @@ -55,6 +55,27 @@ option(MATERIALX_WARNINGS_AS_ERRORS "Interpret all compiler warnings as errors." option(MATERIALX_DYNAMIC_ANALYSIS "Build MaterialX libraries with dynamic analysis on supporting platforms." OFF) option(MATERIALX_OSL_LEGACY_CLOSURES "Build OSL shader generation supporting the legacy OSL closures." ON) +option(MATERIALX_BUILD_IOS "Build MaterialX for iOS." OFF) +if (MATERIALX_BUILD_IOS) + set(CMAKE_SYSTEM_NAME iOS) + add_definitions(-DTARGET_OS_IOS=1) + set(MATERIALX_BUILD_PYTHON OFF) + set(MATERIALX_BUILD_VIEWER OFF) + set(MATERIALX_BUILD_GRAPH_EDITOR OFF) + set(MATERIALX_BUILD_GEN_GLSL OFF) + set(MATERIALX_BUILD_GEN_OSL OFF) + set(MATERIALX_BUILD_GEN_GLSL OFF) + set(MATERIALX_BUILD_GEN_MDL OFF) + set(MATERIALX_BUILD_OIIO OFF) + set(MATERIALX_PYTHON_LTO OFF) + set(MATERIALX_INSTALL_PYTHON OFF) + set(MATERIALX_DYNAMIC_ANALYSIS OFF) + set(MATERIALX_DYNAMIC_ANALYSIS OFF) + set(MATERIALX_OSL_LEGACY_CLOSURES OFF) + set(MATERIALX_BUILD_TESTS OFF) + set(MATERIALX_TEST_RENDER OFF) +endif() + set(MATERIALX_PYTHON_VERSION "" CACHE STRING "Python version to be used in building the MaterialX Python package (e.g. '3.9').") set(MATERIALX_PYTHON_EXECUTABLE "" CACHE FILEPATH @@ -80,6 +101,12 @@ set(MATERIALX_OSL_BINARY_OSLC "" CACHE FILEPATH "Full path to the OSL compiler b set(MATERIALX_OSL_BINARY_TESTRENDER "" CACHE FILEPATH "Full path to the OSL test render binary.") set(MATERIALX_OSL_INCLUDE_PATH "" CACHE PATH "Full path to OSL shader includes (e.g. 'stdosl.h').") +set(MATERIALX_PYTHON_FOLDER_NAME "python/MaterialX" CACHE INTERNAL "Folder name to user for installing the Python library.") + +if(SKBUILD) + set(MATERIALX_PYTHON_FOLDER_NAME "MaterialX") +endif() + # Helpers for MDL validation if (MATERIALX_BUILD_GEN_MDL) set(MATERIALX_MDLC_EXECUTABLE "" CACHE FILEPATH "Full path to the mdlc binary.") @@ -116,6 +143,7 @@ mark_as_advanced(MATERIALX_NAMESPACE_SUFFIX) mark_as_advanced(MATERIALX_LIBNAME_SUFFIX) mark_as_advanced(MATERIALX_PYTHON_LTO) mark_as_advanced(MATERIALX_INSTALL_PYTHON) +mark_as_advanced(MATERIALX_INSTALL_RESOURCES) mark_as_advanced(MATERIALX_TEST_RENDER) mark_as_advanced(MATERIALX_WARNINGS_AS_ERRORS) mark_as_advanced(MATERIALX_DYNAMIC_ANALYSIS) @@ -133,6 +161,7 @@ mark_as_advanced(MATERIALX_INSTALL_LIB_PATH) mark_as_advanced(MATERIALX_INSTALL_STDLIB_PATH) mark_as_advanced(MATERIALX_BUILD_JS) mark_as_advanced(MATERIALX_EMSDK_PATH) +mark_as_advanced(MATERIALX_BUILD_IOS) if (MATERIALX_BUILD_GEN_MDL) mark_as_advanced(MATERIALX_MDLC_EXECUTABLE) mark_as_advanced(MATERIALX_MDL_RENDER_EXECUTABLE) @@ -184,6 +213,12 @@ set(MATERIALX_SAME_DIR_RPATH "${RPATH_RELATIVE_SYMBOL};${CMAKE_INSTALL_PREFIX}/$ set(MATERIALX_UP_ONE_RPATH "${RPATH_RELATIVE_SYMBOL}/../${MATERIALX_INSTALL_LIB_PATH};${MATERIALX_SAME_DIR_RPATH}") # For linking to libraries where source is two directories deep, ie: "MATX/python/MaterialX/../../lib" set(MATERIALX_UP_TWO_RPATH "${RPATH_RELATIVE_SYMBOL}/../../${MATERIALX_INSTALL_LIB_PATH};${MATERIALX_SAME_DIR_RPATH}") +if(SKBUILD) + # When building the Python wheels, we don't want to set any RPATH because + # we want to wheel to be self-contained. We don't want any interference from + # external paths. + set(MATERIALX_UP_TWO_RPATH "${RPATH_RELATIVE_SYMBOL}") +endif() # Adjust compiler settings if(MSVC) @@ -277,7 +312,7 @@ if(MATERIALX_BUILD_RENDER) if(MATERIALX_BUILD_GRAPH_EDITOR) add_subdirectory(source/MaterialXGraphEditor) endif() - if(MATERIALX_INSTALL_RESOURCES) + if(MATERIALX_INSTALL_RESOURCES AND NOT SKBUILD) add_subdirectory(resources) endif() endif() @@ -312,26 +347,28 @@ if(${CMAKE_VERSION} VERSION_GREATER "3.6.2") endif() # Install root-level documents -install(FILES LICENSE CHANGELOG.md README.md THIRD-PARTY.md - DESTINATION .) - -set(MATERIALX_GEN_CONFIG_PATH "${MATERIALX_INSTALL_LIB_PATH}/cmake/${CMAKE_PROJECT_NAME}") - -include(CMakePackageConfigHelpers) -configure_package_config_file(cmake/modules/MaterialXConfig.cmake.in - ${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}Config.cmake - INSTALL_DESTINATION "${MATERIALX_GEN_CONFIG_PATH}" - PATH_VARS CMAKE_INSTALL_PREFIX CMAKE_PROJECT_NAME) -write_basic_package_version_file(${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}ConfigVersion.cmake - VERSION ${MATERIALX_LIBRARY_VERSION} - COMPATIBILITY AnyNewerVersion) - -# Install the auto-generated CMake configuration files: - -install(EXPORT MaterialX - DESTINATION "${MATERIALX_GEN_CONFIG_PATH}" - FILE ${CMAKE_PROJECT_NAME}Targets.cmake) - -install(FILES "${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}ConfigVersion.cmake" - "${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}Config.cmake" - DESTINATION "${MATERIALX_GEN_CONFIG_PATH}") +if(NOT SKBUILD) + install(FILES LICENSE CHANGELOG.md README.md THIRD-PARTY.md + DESTINATION .) + + set(MATERIALX_GEN_CONFIG_PATH "${MATERIALX_INSTALL_LIB_PATH}/cmake/${CMAKE_PROJECT_NAME}") + + include(CMakePackageConfigHelpers) + configure_package_config_file(cmake/modules/MaterialXConfig.cmake.in + ${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}Config.cmake + INSTALL_DESTINATION "${MATERIALX_GEN_CONFIG_PATH}" + PATH_VARS CMAKE_INSTALL_PREFIX CMAKE_PROJECT_NAME) + write_basic_package_version_file(${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}ConfigVersion.cmake + VERSION ${MATERIALX_LIBRARY_VERSION} + COMPATIBILITY AnyNewerVersion) + + # Install the auto-generated CMake configuration files: + + install(EXPORT MaterialX + DESTINATION "${MATERIALX_GEN_CONFIG_PATH}" + FILE ${CMAKE_PROJECT_NAME}Targets.cmake) + + install(FILES "${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}ConfigVersion.cmake" + "${CMAKE_BINARY_DIR}/cmake/${CMAKE_PROJECT_NAME}Config.cmake" + DESTINATION "${MATERIALX_GEN_CONFIG_PATH}") +endif() diff --git a/cmake/modules/MaterialXVersion.rc.in b/cmake/modules/MaterialXVersion.rc.in new file mode 100644 index 0000000000..989fbb8e55 --- /dev/null +++ b/cmake/modules/MaterialXVersion.rc.in @@ -0,0 +1,34 @@ + +#define MATERIALX_FILEVERSION @MATERIALX_MAJOR_VERSION@,@MATERIALX_MINOR_VERSION@,@MATERIALX_BUILD_VERSION@,0 +#define MATERIALX_FILEVERSION_STR "@MATERIALX_MAJOR_VERSION@.@MATERIALX_MINOR_VERSION@.@MATERIALX_BUILD_VERSION@.0\0" +#define MATERIALX_FILENAME_STR "@MATERIALX_MODULE_NAME@.dll\0" + +1 VERSIONINFO + FILEVERSION MATERIALX_FILEVERSION + PRODUCTVERSION MATERIALX_FILEVERSION + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x1L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904E4" + BEGIN + VALUE "FileVersion", MATERIALX_FILEVERSION_STR + VALUE "LegalCopyright", "Apache License 2.0\0" + VALUE "OriginalFilename", MATERIALX_FILENAME_STR + VALUE "ProductName", "MaterialX\0" + VALUE "ProductVersion", MATERIALX_FILEVERSION_STR + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1252 + END +END diff --git a/documents/Specification/MaterialX.Specification.md b/documents/Specification/MaterialX.Specification.md index 3a90a269fb..7e876bdb57 100644 --- a/documents/Specification/MaterialX.Specification.md +++ b/documents/Specification/MaterialX.Specification.md @@ -656,6 +656,7 @@ Standard Texture nodes: * **`image`**: samples data from a single image, or from a layer within a multi-layer image. When used in the context of rendering a geometry, the image is mapped onto the geometry based on geometry UV coordinates, with the lower-left corner of an image mapping to the (0,0) UV coordinate (or to the fractional (0,0) UV coordinate for tiled images). +The type of the <image> node determines the number of channels output, which may be less than the number of channels in the image file, outputting the first N channels from the image file. So a `float` <image> would return the Red channel of an RGB image, and a `color3` <image> would return the RGB channels of an RGBA image. * `file` (uniform filename): the URI of an image file. The filename can include one or more substitutions to change the file name (including frame number) that is accessed, as described in the [Filename Substitutions](#filename-substitutions) section above. * `layer` (uniform string): the name of the layer to extract from a multi-layer input file. If no value for `layer` is provided and the input file has multiple layers, then the "default" layer will be used, or "rgba" if there is no "default" layer. Note: the number of channels defined by the `type` of the `` must match the number of channels in the named layer. * `default` (float or colorN or vectorN): a default value to use if the `file` reference can not be resolved (e.g. if a <_geometry token_>, [_interface token_] or {_hostattr_} is included in the filename but no substitution value or default is defined, or if the resolved `file` URI cannot be read), or if the specified `layer` does not exist in the file. The `default` value must be the same type as the `` element itself. If `default` is not defined, the default color value will be 0.0 in all channels. @@ -786,8 +787,8 @@ Standard Procedural nodes: * **`checkerboard`**: a 2D checkerboard pattern. * `color1` (color3): The first color used in the checkerboard pattern. * `color2` (color3): The second color used in the checkerboard pattern. - * `freq` (vector2): The frequency of checkers, with higher values producing smaller squares. Default is (8, 8). - * `offset` (vector2): Shift the pattern in 2d space. Default is (0, 0). + * `uvtiling` (vector2): The tiling of the checkerboard pattern along each axis, with higher values producing smaller squares. Default is (8, 8). + * `uvoffset` (vector2): The offset of the checkerboard pattern along each axis. Default is (0, 0). * `texcoord` (vector2): The input 2d space. Default is the first texture coordinates. @@ -2369,7 +2370,7 @@ An input with a shader-semantic type may be given a value of "" to indicate no s The Standard MaterialX Library defines the following nodes and node variants operating on "shader"-semantic types. Standard library shaders do not respond to external illumination; please refer to the [**MaterialX Physically Based Shading Nodes**](./MaterialX.PBRSpec.md#materialx-pbs-library) document for definitions of additional nodes and shader constructors which do respond to illumination. - + * **`surface_unlit`**: an unlit surface shader node, representing a surface that can emit and transmit light, but does not receive illumination from light sources or other surfaces. Output type surfaceshader. * `emission` (float): the surface emission amount; default is 1.0 diff --git a/javascript/MaterialXView/package-lock.json b/javascript/MaterialXView/package-lock.json index f22bb7674c..7bdf38ceba 100644 --- a/javascript/MaterialXView/package-lock.json +++ b/javascript/MaterialXView/package-lock.json @@ -10,8 +10,8 @@ "license": "ISC", "dependencies": { "dat.gui": "^0.7.9", - "three": "^0.140.2", - "webpack": "^5.88.1" + "three": "^0.136.0", + "webpack": "^5.88.2" }, "devDependencies": { "copy-webpack-plugin": "^8.1.1", @@ -166,9 +166,9 @@ } }, "node_modules/@types/eslint": { - "version": "8.44.0", - "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.44.0.tgz", - "integrity": "sha512-gsF+c/0XOguWgaOgvFs+xnnRqt9GwgTvIks36WpE6ueeI4KCEHHd8K/CKHqhOqrJKsYH8m27kRzQEvWXAwXUTw==", + "version": "8.44.1", + "resolved": "https://registry.npmjs.org/@types/eslint/-/eslint-8.44.1.tgz", + "integrity": "sha512-XpNDc4Z5Tb4x+SW1MriMVeIsMoONHCkWFMkR/aPJbzEsxqHy+4Glu/BqTdPrApfDeMaXbtNh6bseNgl5KaWrSg==", "dependencies": { "@types/estree": "*", "@types/json-schema": "*" @@ -245,9 +245,9 @@ "dev": true }, "node_modules/@types/node": { - "version": "20.4.2", - "resolved": "https://registry.npmjs.org/@types/node/-/node-20.4.2.tgz", - "integrity": "sha512-Dd0BYtWgnWJKwO1jkmTrzofjK2QXXcai0dmtzvIBhcA+RsG5h8R3xlyta0kGOZRNfL9GuRtb1knmPEhQrePCEw==" + "version": "20.4.5", + "resolved": "https://registry.npmjs.org/@types/node/-/node-20.4.5.tgz", + "integrity": "sha512-rt40Nk13II9JwQBdeYqmbn2Q6IVTA5uPhvSO+JVqdXw/6/4glI6oR9ezty/A9Hg5u7JH4OmYmuQ+XvjKm0Datg==" }, "node_modules/@types/qs": { "version": "6.9.7", @@ -798,9 +798,9 @@ } }, "node_modules/caniuse-lite": { - "version": "1.0.30001515", - "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001515.tgz", - "integrity": "sha512-eEFDwUOZbE24sb+Ecsx3+OvNETqjWIdabMy52oOkIgcUtAsQifjUG9q4U9dgTHJM2mfk4uEPxc0+xuFdJ629QA==", + "version": "1.0.30001517", + "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001517.tgz", + "integrity": "sha512-Vdhm5S11DaFVLlyiKu4hiUTkpZu+y1KA/rZZqVQfOD5YdDT/eQKlkt7NaE0WGOFgX32diqt9MiP9CAiFeRklaA==", "funding": [ { "type": "opencollective", @@ -1223,9 +1223,9 @@ "dev": true }, "node_modules/electron-to-chromium": { - "version": "1.4.460", - "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.460.tgz", - "integrity": "sha512-kKiHnbrHME7z8E6AYaw0ehyxY5+hdaRmeUbjBO22LZMdqTYCO29EvF0T1cQ3pJ1RN5fyMcHl1Lmcsdt9WWJpJQ==" + "version": "1.4.470", + "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.470.tgz", + "integrity": "sha512-zZM48Lmy2FKWgqyvsX9XK+J6FfP7aCDUFLmgooLJzA7v1agCs/sxSoBpTIwDLhmbhpx9yJIxj2INig/ncjJRqg==" }, "node_modules/encodeurl": { "version": "1.0.2", @@ -1427,9 +1427,9 @@ "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==" }, "node_modules/fast-glob": { - "version": "3.3.0", - "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.0.tgz", - "integrity": "sha512-ChDuvbOypPuNjO8yIDf36x7BlZX1smcUMTTcyoIjycexOxd6DFsKsg21qVBzEmr3G7fUKIRy2/psii+CIUt7FA==", + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/fast-glob/-/fast-glob-3.3.1.tgz", + "integrity": "sha512-kNFPyjhh5cKjrUltxs+wFx+ZkbRaxxmZ+X0ZU31SOsxCEtP9VPgtq2teZw1DebupL5GmDaNQ6yKMMVcM41iqDg==", "dev": true, "dependencies": { "@nodelib/fs.stat": "^2.0.2", @@ -3405,9 +3405,9 @@ } }, "node_modules/terser": { - "version": "5.19.0", - "resolved": "https://registry.npmjs.org/terser/-/terser-5.19.0.tgz", - "integrity": "sha512-JpcpGOQLOXm2jsomozdMDpd5f8ZHh1rR48OFgWUH3QsyZcfPgv2qDCYbcDEAYNd4OZRj2bWYKpwdll/udZCk/Q==", + "version": "5.19.2", + "resolved": "https://registry.npmjs.org/terser/-/terser-5.19.2.tgz", + "integrity": "sha512-qC5+dmecKJA4cpYxRa5aVkKehYsQKc+AHeKl0Oe62aYjBL8ZA33tTljktDHJSaxxMnbI5ZYw+o/S2DxxLu8OfA==", "dependencies": { "@jridgewell/source-map": "^0.3.3", "acorn": "^8.8.2", @@ -3468,9 +3468,9 @@ "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==" }, "node_modules/three": { - "version": "0.140.2", - "resolved": "https://registry.npmjs.org/three/-/three-0.140.2.tgz", - "integrity": "sha512-DdT/AHm/TbZXEhQKQpGt5/iSgBrmXpjU26FNtj1KhllVPTKj1eG4X/ShyD5W2fngE+I1s1wa4ttC4C3oCJt7Ag==" + "version": "0.136.0", + "resolved": "https://registry.npmjs.org/three/-/three-0.136.0.tgz", + "integrity": "sha512-+fEMX7nYLz2ZesVP/dyifli5Jf8gR3XPAnFJveQ80aMhibFduzrADnjMbARXh8+W9qLK7rshJCjAIL/6cDxC+A==" }, "node_modules/thunky": { "version": "1.1.0", @@ -3500,9 +3500,9 @@ } }, "node_modules/tslib": { - "version": "2.6.0", - "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.0.tgz", - "integrity": "sha512-7At1WUettjcSRHXCyYtTselblcHl9PJFFVKiCAy/bY97+BPZXSQ2wbq0P9s8tK2G7dFQfNnlJnPAiArVBVBsfA==", + "version": "2.6.1", + "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.6.1.tgz", + "integrity": "sha512-t0hLfiEKfMUoqhG+U1oid7Pva4bbDPHYfJNiB7BiIjRkj1pyC++4N3huJfqY6aRH6VTB0rvtzQwjM4K6qpfOig==", "dev": true }, "node_modules/type-is": { @@ -3625,9 +3625,9 @@ } }, "node_modules/webpack": { - "version": "5.88.1", - "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.88.1.tgz", - "integrity": "sha512-FROX3TxQnC/ox4N+3xQoWZzvGXSuscxR32rbzjpXgEzWudJFEJBpdlkkob2ylrv5yzzufD1zph1OoFsLtm6stQ==", + "version": "5.88.2", + "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.88.2.tgz", + "integrity": "sha512-JmcgNZ1iKj+aiR0OvTYtWQqJwq37Pf683dY9bVORwVbUrDhLhdn/PlO2sHsFHPkj7sHNQF3JwaAkp49V+Sq1tQ==", "dependencies": { "@types/eslint-scope": "^3.7.3", "@types/estree": "^1.0.0", diff --git a/javascript/MaterialXView/package.json b/javascript/MaterialXView/package.json index 7ee8611600..adce3d2e82 100644 --- a/javascript/MaterialXView/package.json +++ b/javascript/MaterialXView/package.json @@ -11,8 +11,8 @@ "license": "ISC", "dependencies": { "dat.gui": "^0.7.9", - "three": "^0.140.2", - "webpack": "^5.88.1" + "three": "^0.136.0", + "webpack": "^5.88.2" }, "devDependencies": { "copy-webpack-plugin": "^8.1.1", diff --git a/javascript/MaterialXView/source/dropHandling.js b/javascript/MaterialXView/source/dropHandling.js new file mode 100644 index 0000000000..adcbef2ca1 --- /dev/null +++ b/javascript/MaterialXView/source/dropHandling.js @@ -0,0 +1,281 @@ +import * as THREE from 'three'; +import * as fflate from 'three/examples/jsm/libs/fflate.module.js'; + +const debugFileHandling = false; +let loadingCallback; + +export function setLoadingCallback(cb) { + loadingCallback = cb; +} + +export function dropHandler(ev) { + if (debugFileHandling) console.log('File(s) dropped', ev.dataTransfer.items, ev.dataTransfer.files); + + // Prevent default behavior (Prevent file from being opened) + ev.preventDefault(); + + if (ev.dataTransfer.items) + { + const allEntries = []; + + let haveGetAsEntry = false; + if (ev.dataTransfer.items.length > 0) + haveGetAsEntry = + ("getAsEntry" in ev.dataTransfer.items[0]) || + ("webkitGetAsEntry" in ev.dataTransfer.items[0]); + + // Useful for debugging file handling on platforms that don't support newer file system APIs + // haveGetAsEntry = false; + + if (haveGetAsEntry) { + for (var i = 0; i < ev.dataTransfer.items.length; i++) + { + let item = ev.dataTransfer.items[i]; + let entry = ("getAsEntry" in item) ? item.getAsEntry() : item.webkitGetAsEntry(); + allEntries.push(entry); + } + handleFilesystemEntries(allEntries); + return; + } + + for (var i = 0; i < ev.dataTransfer.items.length; i++) + { + let item = ev.dataTransfer.items[i]; + + // API when there's no "getAsEntry" support + console.log(item.kind, item); + if (item.kind === 'file') + { + var file = item.getAsFile(); + testAndLoadFile(file); + } + // could also be a directory + else if (item.kind === 'directory') + { + var dirReader = item.createReader(); + dirReader.readEntries(function(entries) { + for (var i = 0; i < entries.length; i++) { + console.log(entries[i].name); + var entry = entries[i]; + if (entry.isFile) { + entry.file(function(file) { + testAndLoadFile(file); + }); + } + } + }); + } + } + } else { + for (var i = 0; i < ev.dataTransfer.files.length; i++) { + let file = ev.dataTransfer.files[i]; + testAndLoadFile(file); + } + } +} + +export function dragOverHandler(ev) { + ev.preventDefault(); +} + +async function getBufferFromFile(fileEntry) { + + if (fileEntry instanceof ArrayBuffer) return fileEntry; + if (fileEntry instanceof String) return fileEntry; + + const name = fileEntry.fullPath || fileEntry.name; + const ext = name.split('.').pop(); + const readAsText = ext === 'mtlx'; + + if (debugFileHandling) console.log("reading ", fileEntry, "as text?", readAsText); + + if (debugFileHandling) console.log("getBufferFromFile", fileEntry); + const buffer = await new Promise((resolve, reject) => { + function readFile(file) { + var reader = new FileReader(); + reader.onloadend = function(e) { + if (debugFileHandling) console.log("loaded", "should be text?", readAsText, this.result); + resolve(this.result); + }; + + if (readAsText) + reader.readAsText(file); + else + reader.readAsArrayBuffer(file); + } + + if ("file" in fileEntry) { + fileEntry.file(function(file) { + readFile(file); + }, (e) => { + console.error("Error reading file ", e); + }); + } + else { + readFile(fileEntry); + } + }); + return buffer; +} + +async function handleFilesystemEntries(entries) { + const allFiles = []; + const fileIgnoreList = [ + '.gitignore', + 'README.md', + '.DS_Store', + ] + const dirIgnoreList = [ + '.git', + 'node_modules', + ] + + for (let entry of entries) { + if (debugFileHandling) console.log("file entry", entry) + if (entry.isFile) { + if (debugFileHandling) console.log("single file", entry); + if (fileIgnoreList.includes(entry.name)) { + continue; + } + allFiles.push(entry); + } + else if (entry.isDirectory) { + if (dirIgnoreList.includes(entry.name)) { + continue; + } + const files = await readDirectory(entry); + if (debugFileHandling) console.log("all files", files); + for (const file of files) { + if (fileIgnoreList.includes(file.name)) { + continue; + } + allFiles.push(file); + } + } + } + + const imageLoader = new THREE.ImageLoader(); + + // unpack zip files first + for (const fileEntry of allFiles) { + // special case: zip archives + if (fileEntry.fullPath.toLowerCase().endsWith('.zip')) { + await new Promise(async (resolve, reject) => { + const arrayBuffer = await getBufferFromFile(fileEntry); + + // use fflate to unpack them and add the files to the cache + fflate.unzip(new Uint8Array(arrayBuffer), (error, unzipped) => { + // push these files into allFiles + for (const [filePath, buffer] of Object.entries(unzipped)) { + + // mock FileEntry for easier usage downstream + const blob = new Blob([buffer]); + const newFileEntry = { + fullPath: "/" + filePath, + name: filePath.split('/').pop(), + file: (callback) => { + callback(blob); + }, + isFile: true, + }; + allFiles.push(newFileEntry); + } + + resolve(); + }); + }); + } + } + + // sort so mtlx files come first + allFiles.sort((a, b) => { + if (a.name.endsWith('.mtlx') && !b.name.endsWith('.mtlx')) { + return -1; + } + if (!a.name.endsWith('.mtlx') && b.name.endsWith('.mtlx')) { + return 1; + } + return 0; + }); + + if (debugFileHandling) console.log("all files", allFiles); + + // put all files in three' Cache + for (const fileEntry of allFiles) { + + const allowedFileTypes = [ + 'png', 'jpg', 'jpeg' + ]; + + const ext = fileEntry.fullPath.split('.').pop(); + if (!allowedFileTypes.includes(ext)) { + // console.log("skipping file", fileEntry.fullPath); + continue; + } + + const buffer = await getBufferFromFile(fileEntry); + const img = await imageLoader.loadAsync(URL.createObjectURL(new Blob([buffer]))); + if (debugFileHandling) console.log("caching file", fileEntry.fullPath, img); + THREE.Cache.add(fileEntry.fullPath, img); + } + + // TODO we could also allow dropping of multiple MaterialX files (or folders with them inside) + // and seed the dropdown from that. + // At that point, actually reading files and textures into memory should be deferred until they are actually used. + const rootFile = allFiles[0]; + THREE.Cache.add(rootFile.fullPath, await getBufferFromFile(rootFile)); + + if (debugFileHandling) console.log("CACHE", THREE.Cache.files); + + loadingCallback(rootFile); +} + +async function readDirectory(directory) { + let entries = []; + let getEntries = async (directory) => { + let dirReader = directory.createReader(); + await new Promise((resolve, reject) => { + dirReader.readEntries( + async (results) => { + if (results.length) { + // entries = entries.concat(results); + for (let entry of results) { + if (entry.isDirectory) { + await getEntries(entry); + } + else { + entries.push(entry); + } + } + } + resolve(); + }, + (error) => { + /* handle error — error is a FileError object */ + }, + )} + )}; + + await getEntries(directory); + return entries; +} + +async function testAndLoadFile(file) { + let ext = file.name.split('.').pop(); + if (debugFileHandling) console.log(file.name + ", " + file.size + ", " + ext); + + const arrayBuffer = await getBufferFromFile(file); + console.log(arrayBuffer) + + // mock a fileEntry and pass through the same loading logic + const newFileEntry = { + fullPath: "/" + file.name, + name: file.name.split('/').pop(), + isFile: true, + file: (callback) => { + callback(file); + } + }; + + handleFilesystemEntries([newFileEntry]); +} \ No newline at end of file diff --git a/javascript/MaterialXView/source/index.js b/javascript/MaterialXView/source/index.js index 424f63ec43..56e2e1f5a2 100644 --- a/javascript/MaterialXView/source/index.js +++ b/javascript/MaterialXView/source/index.js @@ -12,6 +12,7 @@ import { ShaderPass } from 'three/examples/jsm/postprocessing/ShaderPass.js'; import { GammaCorrectionShader } from 'three/examples/jsm/shaders/GammaCorrectionShader.js'; import { Viewer } from './viewer.js' +import { dropHandler, dragOverHandler, setLoadingCallback } from './dropHandling.js'; let renderer, composer, orbitControls; @@ -115,6 +116,20 @@ function init() console.error(Number.isInteger(err) ? this.getMx().getExceptionMessage(err) : err); }) + // allow dropping files and directories + document.addEventListener('drop', dropHandler, false); + document.addEventListener('dragover', dragOverHandler, false); + + setLoadingCallback(file => { + materialFilename = file.fullPath || file.name; + viewer.getEditor().clearFolders(); + viewer.getMaterial().loadMaterials(viewer, materialFilename); + viewer.getEditor().updateProperties(0.9); + viewer.getScene().setUpdateTransforms(); + }); + + // enable three.js Cache so that dropped files can reference each other + THREE.Cache.enabled = true; } function onWindowResize() diff --git a/javascript/MaterialXView/source/viewer.js b/javascript/MaterialXView/source/viewer.js index 126b5d5bca..d1adfd9ef4 100644 --- a/javascript/MaterialXView/source/viewer.js +++ b/javascript/MaterialXView/source/viewer.js @@ -589,6 +589,7 @@ export class Material // Set search path. Assumes images are relative to current file // location. + if (!materialFilename) materialFilename = "/"; const paths = materialFilename.split('/'); paths.pop(); const searchPath = paths.join('/'); @@ -777,7 +778,7 @@ export class Material Object.assign(uniforms, { u_numActiveLightSources: { value: lights.length }, u_lightData: { value: lightData }, - u_envMatrix: { value: new THREE.Matrix4().multiplyMatrices(getLightRotation(), new THREE.Matrix4().makeScale(1, -1, 1)) }, + u_envMatrix: { value: getLightRotation() }, u_envRadiance: { value: radianceTexture }, u_envRadianceMips: { value: Math.trunc(Math.log2(Math.max(radianceTexture.image.width, radianceTexture.image.height))) + 1 }, u_envRadianceSamples: { value: 16 }, diff --git a/libraries/CMakeLists.txt b/libraries/CMakeLists.txt index 0d47cad5ed..d60a54cf3b 100644 --- a/libraries/CMakeLists.txt +++ b/libraries/CMakeLists.txt @@ -1,20 +1,28 @@ -install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ - DESTINATION "${MATERIALX_INSTALL_STDLIB_PATH}" MESSAGE_NEVER - PATTERN "CMakeLists.txt" EXCLUDE - PATTERN "pbrlib_genosl_impl.*" EXCLUDE) - if (MATERIALX_OSL_LEGACY_CLOSURES) set(PBRLIB_SUFFIX "legacy") else() set(PBRLIB_SUFFIX "mtlx") endif() -install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/pbrlib/genosl/pbrlib_genosl_impl.${PBRLIB_SUFFIX}" - DESTINATION "${MATERIALX_INSTALL_STDLIB_PATH}/pbrlib/genosl/" RENAME pbrlib_genosl_impl.mtlx) +if(NOT SKBUILD) + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ + DESTINATION "${MATERIALX_INSTALL_STDLIB_PATH}" + PATTERN "CMakeLists.txt" EXCLUDE + PATTERN "pbrlib_genosl_impl.*" EXCLUDE) + install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/pbrlib/genosl/pbrlib_genosl_impl.${PBRLIB_SUFFIX}" + DESTINATION "${MATERIALX_INSTALL_STDLIB_PATH}/pbrlib/genosl/" RENAME pbrlib_genosl_impl.mtlx) +endif() -install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ - DESTINATION "python/MaterialX/${MATERIALX_INSTALL_STDLIB_PATH}" - PATTERN "CMakeLists.txt" EXCLUDE - PATTERN "pbrlib_genosl_impl.*" EXCLUDE) -install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/pbrlib/genosl/pbrlib_genosl_impl.${PBRLIB_SUFFIX}" - DESTINATION "python/MaterialX/${MATERIALX_INSTALL_STDLIB_PATH}/pbrlib/genosl/" RENAME pbrlib_genosl_impl.mtlx) +set(MATERIALX_PYTHON_LIBRARIES_PATH "${MATERIALX_PYTHON_FOLDER_NAME}/${MATERIALX_INSTALL_STDLIB_PATH}") +if(SKBUILD) + set(MATERIALX_PYTHON_LIBRARIES_PATH "${SKBUILD_PLATLIB_DIR}/MaterialX/libraries") +endif() + +if(MATERIALX_BUILD_PYTHON) + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ + DESTINATION "${MATERIALX_PYTHON_LIBRARIES_PATH}" + PATTERN "CMakeLists.txt" EXCLUDE + PATTERN "pbrlib_genosl_impl.*" EXCLUDE) + install(FILES "${CMAKE_CURRENT_SOURCE_DIR}/pbrlib/genosl/pbrlib_genosl_impl.${PBRLIB_SUFFIX}" + DESTINATION "${MATERIALX_PYTHON_LIBRARIES_PATH}/pbrlib/genosl/" RENAME pbrlib_genosl_impl.mtlx) +endif() diff --git a/libraries/bxdf/gltf_pbr.mtlx b/libraries/bxdf/gltf_pbr.mtlx index cb393fb82a..6654e63454 100644 --- a/libraries/bxdf/gltf_pbr.mtlx +++ b/libraries/bxdf/gltf_pbr.mtlx @@ -359,7 +359,7 @@ - + @@ -375,13 +375,10 @@ - - - - + @@ -422,7 +419,7 @@ - + @@ -434,9 +431,6 @@ - - - @@ -458,7 +452,7 @@ - + @@ -480,7 +474,7 @@ - + @@ -492,9 +486,6 @@ - - - @@ -516,7 +507,7 @@ - + @@ -538,7 +529,7 @@ - + @@ -550,9 +541,6 @@ - - - @@ -574,7 +562,7 @@ - + @@ -595,7 +583,7 @@ - + @@ -607,9 +595,6 @@ - - - @@ -631,7 +616,7 @@ - + @@ -648,7 +633,7 @@ - + @@ -660,9 +645,6 @@ - - - @@ -687,7 +669,7 @@ - + @@ -704,7 +686,7 @@ - + @@ -725,7 +707,7 @@ - + diff --git a/libraries/stdlib/genglsl/mx_image_color3.glsl b/libraries/stdlib/genglsl/mx_image_color3.glsl index 802318f475..8c4c039554 100644 --- a/libraries/stdlib/genglsl/mx_image_color3.glsl +++ b/libraries/stdlib/genglsl/mx_image_color3.glsl @@ -2,13 +2,6 @@ void mx_image_color3(sampler2D tex_sampler, int layer, vec3 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec3 result) { - if (textureSize(tex_sampler, 0).x > 1) - { - vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); - result = texture(tex_sampler, uv).rgb; - } - else - { - result = defaultval; - } + vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); + result = texture(tex_sampler, uv).rgb; } diff --git a/libraries/stdlib/genglsl/mx_image_color4.glsl b/libraries/stdlib/genglsl/mx_image_color4.glsl index e74ad9445f..7541b9da04 100644 --- a/libraries/stdlib/genglsl/mx_image_color4.glsl +++ b/libraries/stdlib/genglsl/mx_image_color4.glsl @@ -2,13 +2,6 @@ void mx_image_color4(sampler2D tex_sampler, int layer, vec4 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec4 result) { - if (textureSize(tex_sampler, 0).x > 1) - { - vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); - result = texture(tex_sampler, uv); - } - else - { - result = defaultval; - } + vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); + result = texture(tex_sampler, uv); } diff --git a/libraries/stdlib/genglsl/mx_image_float.glsl b/libraries/stdlib/genglsl/mx_image_float.glsl index 9b831035d2..0a402a101c 100644 --- a/libraries/stdlib/genglsl/mx_image_float.glsl +++ b/libraries/stdlib/genglsl/mx_image_float.glsl @@ -2,13 +2,6 @@ void mx_image_float(sampler2D tex_sampler, int layer, float defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out float result) { - if (textureSize(tex_sampler, 0).x > 1) - { - vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); - result = texture(tex_sampler, uv).r; - } - else - { - result = defaultval; - } + vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); + result = texture(tex_sampler, uv).r; } diff --git a/libraries/stdlib/genglsl/mx_image_vector2.glsl b/libraries/stdlib/genglsl/mx_image_vector2.glsl index 124cb09287..42a7235297 100644 --- a/libraries/stdlib/genglsl/mx_image_vector2.glsl +++ b/libraries/stdlib/genglsl/mx_image_vector2.glsl @@ -2,13 +2,6 @@ void mx_image_vector2(sampler2D tex_sampler, int layer, vec2 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec2 result) { - if (textureSize(tex_sampler, 0).x > 1) - { - vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); - result = texture(tex_sampler, uv).rg; - } - else - { - result = defaultval; - } + vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); + result = texture(tex_sampler, uv).rg; } diff --git a/libraries/stdlib/genglsl/mx_image_vector3.glsl b/libraries/stdlib/genglsl/mx_image_vector3.glsl index 840e60fe6f..d49eab735e 100644 --- a/libraries/stdlib/genglsl/mx_image_vector3.glsl +++ b/libraries/stdlib/genglsl/mx_image_vector3.glsl @@ -2,13 +2,6 @@ void mx_image_vector3(sampler2D tex_sampler, int layer, vec3 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec3 result) { - if (textureSize(tex_sampler, 0).x > 1) - { - vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); - result = texture(tex_sampler, uv).rgb; - } - else - { - result = defaultval; - } + vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); + result = texture(tex_sampler, uv).rgb; } diff --git a/libraries/stdlib/genglsl/mx_image_vector4.glsl b/libraries/stdlib/genglsl/mx_image_vector4.glsl index f4b61d83f0..c8bdc66fc4 100644 --- a/libraries/stdlib/genglsl/mx_image_vector4.glsl +++ b/libraries/stdlib/genglsl/mx_image_vector4.glsl @@ -2,13 +2,6 @@ void mx_image_vector4(sampler2D tex_sampler, int layer, vec4 defaultval, vec2 texcoord, int uaddressmode, int vaddressmode, int filtertype, int framerange, int frameoffset, int frameendaction, vec2 uv_scale, vec2 uv_offset, out vec4 result) { - if (textureSize(tex_sampler, 0).x > 1) - { - vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); - result = texture(tex_sampler, uv); - } - else - { - result = defaultval; - } + vec2 uv = mx_transform_uv(texcoord, uv_scale, uv_offset); + result = texture(tex_sampler, uv); } diff --git a/libraries/stdlib/stdlib_defs.mtlx b/libraries/stdlib/stdlib_defs.mtlx index 619d8b5733..a1266176a6 100644 --- a/libraries/stdlib/stdlib_defs.mtlx +++ b/libraries/stdlib/stdlib_defs.mtlx @@ -307,6 +307,7 @@ + @@ -324,6 +325,7 @@ + @@ -341,6 +343,7 @@ + @@ -358,6 +361,7 @@ + @@ -375,6 +379,7 @@ + @@ -392,6 +397,7 @@ + @@ -1083,12 +1089,131 @@ - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/libraries/stdlib/stdlib_ng.mtlx b/libraries/stdlib/stdlib_ng.mtlx index ab1332e79d..e031e72412 100644 --- a/libraries/stdlib/stdlib_ng.mtlx +++ b/libraries/stdlib/stdlib_ng.mtlx @@ -226,11 +226,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -242,7 +276,7 @@ - + @@ -254,7 +288,7 @@ - + @@ -346,11 +380,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -362,7 +430,7 @@ - + @@ -374,7 +442,7 @@ - + @@ -466,11 +534,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -482,7 +584,7 @@ - + @@ -494,7 +596,7 @@ - + @@ -586,11 +688,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -602,7 +738,7 @@ - + @@ -614,7 +750,7 @@ - + @@ -706,11 +842,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -722,7 +892,7 @@ - + @@ -734,7 +904,7 @@ - + @@ -826,11 +996,45 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + @@ -842,7 +1046,7 @@ - + @@ -854,7 +1058,7 @@ - + @@ -1376,49 +1580,788 @@ A 2D checkerboard pattern. --> - - - - - + + + + + + + + + + + + + + + + + - + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - + + + + + + + + + + + + + + + + - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000..e674339900 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,78 @@ +[build-system] +# Use a fixed version because we use an experimental feature +# (a custom plugin) and for now that functionality has +# no compatibility promises. +requires = ["scikit-build-core==0.4.4"] +build-backend = "scikit_build_core.build" + +[project] +name = "MaterialX" +dynamic = ["version"] + +authors = [ + { name="Contributors to the MaterialX project", email="materialx-discussion@lists.aswf.io" }, +] +readme = "README.md" +requires-python = ">=3.6" + +classifiers = [ + "Programming Language :: Python :: 3", + "License :: OSI Approved :: Apache Software License", + "Operating System :: OS Independent", +] + +[project.urls] +"Homepage" = "https://materialx.org" +"Source" = "https://github.com/AcademySoftwareFoundation/MaterialX" +"Bug Tracker" = "https://github.com/AcademySoftwareFoundation/MaterialX/issues" + +[project.scripts] +baketextures = "MaterialX._scripts.baketextures:main" +generateshader = "MaterialX._scripts.generateshader:main" +genmdl = "MaterialX._scripts.genmdl:main" +mxdoc = "MaterialX._scripts.mxdoc:main" +mxupdate = "MaterialX._scripts.mxupdate:main" +mxvalidate = "MaterialX._scripts.mxvalidate:main" +translateshader = "MaterialX._scripts.translateshader:main" +writenodegraphs = "MaterialX._scripts.writenodegraphs:main" + +[tool.scikit-build] +cmake.minimum-version = "3.18" +cmake.verbose = false +cmake.build-type = "Release" + +# Enable experimental features if any are available +# In this case we need custom local plugin to get +# the project version from cmake. +experimental = true +metadata.version.provider = "mtx_skbuild_plugin" +metadata.version.provider-path = "./python" + +# Uncoment when developing locally to enable inplace builds. +# build-dir = "build/" + +logging.level = "DEBUG" + +# Since the python package doesn't live in a standard directory +# in the source (i.e ./src or ./), we need to manually specify +# where the package is. +wheel.packages = ["python/MaterialX"] + +sdist.exclude = [ + "/build", + "/dist", + "/resources", + "/javascript", + "/documents", + "/.github", + "MANIFEST.in" +] + +[tool.scikit-build.cmake.define] +MATERIALX_BUILD_SHARED_LIBS = 'OFF' # Be explicit +MATERIALX_BUILD_PYTHON = 'ON' +MATERIALX_TEST_RENDER = 'OFF' +MATERIALX_WARNINGS_AS_ERRORS = 'ON' +MATERIALX_BUILD_TESTS = 'OFF' +# TODO: How could we harmonize this variable with SKBUILD? +MATERIALX_INSTALL_PYTHON = 'OFF' diff --git a/python/CMakeLists.txt b/python/CMakeLists.txt index e036c5abd5..da35a38b72 100644 --- a/python/CMakeLists.txt +++ b/python/CMakeLists.txt @@ -1,18 +1,25 @@ -set(SETUP_PY_IN "${CMAKE_CURRENT_SOURCE_DIR}/setup.py.in") -set(SETUP_PY "${CMAKE_INSTALL_PREFIX}/python/setup.py") - -configure_file(${SETUP_PY_IN} ${SETUP_PY}) +if(NOT SKBUILD) + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/MaterialX" DESTINATION "python" MESSAGE_NEVER) + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Scripts" DESTINATION "python" MESSAGE_NEVER) +endif() -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/MaterialX" DESTINATION "python" MESSAGE_NEVER) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Scripts" DESTINATION "python" MESSAGE_NEVER) +if(SKBUILD) + install( + DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/Scripts/" + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}/_scripts" + PATTERN "README.md" EXCLUDE + ) +endif() if(MATERIALX_PYTHON_OCIO_DIR) if(NOT EXISTS "${MATERIALX_PYTHON_OCIO_DIR}/config.ocio") message(WARNING "No file named config.ocio was found in the given OCIO directory.") endif() - install(DIRECTORY "${MATERIALX_PYTHON_OCIO_DIR}/" DESTINATION "python/MaterialX/config/" MESSAGE_NEVER) + install(DIRECTORY "${MATERIALX_PYTHON_OCIO_DIR}/" DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}/config/" MESSAGE_NEVER) endif() -if(MATERIALX_INSTALL_PYTHON AND PYTHON_EXECUTABLE) - install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SETUP_PY} install clean --all)" MESSAGE_NEVER) +if(MATERIALX_INSTALL_PYTHON AND PYTHON_EXECUTABLE AND NOT SKBUILD) + set(SETUP_PY "${CMAKE_INSTALL_PREFIX}/python/setup.py") + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/setup.py.in" "${SETUP_PY}") + install(CODE "execute_process(COMMAND ${PYTHON_EXECUTABLE} ${SETUP_PY} install clean --all)") endif() diff --git a/python/MaterialX/_scripts/README.md b/python/MaterialX/_scripts/README.md new file mode 100644 index 0000000000..f3586c5133 --- /dev/null +++ b/python/MaterialX/_scripts/README.md @@ -0,0 +1,2 @@ +This directory is empty buit it's used when packaging the Python library. +the files in ../../Scripts will be copied inside. diff --git a/python/MaterialX/_scripts/__init__.py b/python/MaterialX/_scripts/__init__.py new file mode 100644 index 0000000000..1217aefc79 --- /dev/null +++ b/python/MaterialX/_scripts/__init__.py @@ -0,0 +1 @@ +# Only required for entry-points. diff --git a/python/mtx_skbuild_plugin.py b/python/mtx_skbuild_plugin.py new file mode 100644 index 0000000000..56de6a9f53 --- /dev/null +++ b/python/mtx_skbuild_plugin.py @@ -0,0 +1,90 @@ +""" +This is a custom scikit-build-core plugin that will +fetch the MaterialX version from the CMake project. +""" +import os +import tempfile +import subprocess +from pathlib import Path +from typing import FrozenSet, Dict, Optional, Union, List + +from scikit_build_core.file_api.query import stateless_query +from scikit_build_core.file_api.reply import load_reply_dir + + +def dynamic_metadata( + fields: FrozenSet[str], + settings: Optional[Dict[str, object]] = None, +) -> Dict[str, Union[str, Dict[str, Optional[str]]]]: + print("mtx_skbuild_plugin: Computing MaterialX version from CMake...") + + if fields != {"version"}: + msg = "Only the 'version' field is supported" + raise ValueError(msg) + + if settings: + msg = "No inline configuration is supported" + raise ValueError(msg) + + current_dir = os.path.dirname(__file__) + + with tempfile.TemporaryDirectory() as tmpdir: + # We will use CMake's file API to get the version + # instead of parsing the CMakeLists files. + + # First generate the query folder so that CMake can generate replies. + reply_dir = stateless_query(Path(tmpdir)) + + # Run cmake (configure). CMake will generate a reply automatically. + try: + subprocess.run( + [ + "cmake", + "-S", + os.path.dirname(current_dir), + "-B", + tmpdir, + "-DMATERIALX_BUILD_SHARED_LIBS=OFF", + "-DMATERIALX_BUILD_PYTHON=OFF", + "-DMATERIALX_TEST_RENDER=OFF", + "-DMATERIALX_BUILD_TESTS=OFF", + "-DMATERIALX_INSTALL_PYTHON=OFF", + "-DMATERIALX_BUILD_RENDER=OFF", + ], + stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, + check=True, + text=True, + ) + except subprocess.CalledProcessError as exc: + print(exc.stdout) + raise RuntimeError( + "Failed to configure project to get the version" + ) from exc + + # Get the generated replies. + index = load_reply_dir(reply_dir) + + # Get the version from the CMAKE_PROJECT_VERSION variable. + entries = [ + entry + for entry in index.reply.cache_v2.entries + if entry.name == "CMAKE_PROJECT_VERSION" + ] + + if not entries: + raise ValueError("Could not find MaterialX version from CMake project") + + if len(entries) > 1: + raise ValueError("More than one entry for CMAKE_PROJECT_VERSION found...") + + version = entries[0].value + print("mtx_skbuild_plugin: Computed version: {0}".format(version)) + + return {"version": version} + + +def get_requires_for_dynamic_metadata( + _settings: Optional[Dict[str, object]] = None, +) -> List[str]: + return ["cmake"] diff --git a/resources/CMakeLists.txt b/resources/CMakeLists.txt index 5c1a433cf9..10212c95c2 100644 --- a/resources/CMakeLists.txt +++ b/resources/CMakeLists.txt @@ -1,2 +1,4 @@ -install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ - DESTINATION "resources" MESSAGE_NEVER) +if(NOT SKBUILD) + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/ + DESTINATION "resources" MESSAGE_NEVER) +endif() diff --git a/resources/Materials/TestSuite/stdlib/nodegraph_inputs/top_level_input.mtlx b/resources/Materials/TestSuite/stdlib/nodegraph_inputs/top_level_input.mtlx new file mode 100644 index 0000000000..d92eae7f19 --- /dev/null +++ b/resources/Materials/TestSuite/stdlib/nodegraph_inputs/top_level_input.mtlx @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/resources/Materials/TestSuite/stdlib/procedural/linepattern.mtlx b/resources/Materials/TestSuite/stdlib/procedural/linepattern.mtlx new file mode 100644 index 0000000000..032abf129d --- /dev/null +++ b/resources/Materials/TestSuite/stdlib/procedural/linepattern.mtlx @@ -0,0 +1,39 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/Materials/TestSuite/stdlib/procedural/tiledshape.mtlx b/resources/Materials/TestSuite/stdlib/procedural/tiledshape.mtlx new file mode 100644 index 0000000000..69fd225f2c --- /dev/null +++ b/resources/Materials/TestSuite/stdlib/procedural/tiledshape.mtlx @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/resources/Materials/TestSuite/stdlib/texture/image_default.mtlx b/resources/Materials/TestSuite/stdlib/texture/image_default.mtlx new file mode 100644 index 0000000000..89b99c3c39 --- /dev/null +++ b/resources/Materials/TestSuite/stdlib/texture/image_default.mtlx @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/source/MaterialXCore/CMakeLists.txt b/source/MaterialXCore/CMakeLists.txt index 37edf7929a..33e4fafdf4 100644 --- a/source/MaterialXCore/CMakeLists.txt +++ b/source/MaterialXCore/CMakeLists.txt @@ -1,25 +1,33 @@ +set(MATERIALX_MODULE_NAME MaterialXCore) + configure_file(${CMAKE_CURRENT_SOURCE_DIR}/Generated.h.in ${CMAKE_CURRENT_BINARY_DIR}/Generated.h) file(GLOB materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h" "${CMAKE_CURRENT_BINARY_DIR}/*.h") -add_library(MaterialXCore ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_CORE_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXCore PROPERTIES - OUTPUT_NAME MaterialXCore${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" VERSION "${MATERIALX_LIBRARY_VERSION}" SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXCore + ${MATERIALX_MODULE_NAME} ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXCore +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ @@ -27,14 +35,16 @@ target_include_directories(MaterialXCore PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXCore - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(FILES ${materialx_headers} - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXCore/) + install(FILES ${materialx_headers} + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/) -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXCore.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXCore/Document.cpp b/source/MaterialXCore/Document.cpp index f1a0c4bd1a..4ba48cc84b 100644 --- a/source/MaterialXCore/Document.cpp +++ b/source/MaterialXCore/Document.cpp @@ -86,6 +86,7 @@ class Document::Cache for (ElementPtr elem : doc.lock()->traverseTree()) { const string& nodeName = elem->getAttribute(PortElement::NODE_NAME_ATTRIBUTE); + const string& nodeGraphName = elem->getAttribute(PortElement::NODE_GRAPH_ATTRIBUTE); const string& nodeString = elem->getAttribute(NodeDef::NODE_ATTRIBUTE); const string& nodeDefString = elem->getAttribute(InterfaceElement::NODE_DEF_ATTRIBUTE); @@ -97,6 +98,17 @@ class Document::Cache portElementMap.emplace(portElem->getQualifiedName(nodeName), portElem); } } + else + { + if (!nodeGraphName.empty()) + { + PortElementPtr portElem = elem->asA(); + if (portElem) + { + portElementMap.emplace(portElem->getQualifiedName(nodeGraphName), portElem); + } + } + } if (!nodeString.empty()) { NodeDefPtr nodeDef = elem->asA(); diff --git a/source/MaterialXCore/Element.h b/source/MaterialXCore/Element.h index 8e43d9aa33..51e5f7dc24 100644 --- a/source/MaterialXCore/Element.h +++ b/source/MaterialXCore/Element.h @@ -300,7 +300,7 @@ class MX_CORE_API Element : public std::enable_shared_from_this /// Return the element, if any, that this one directly inherits from. ElementPtr getInheritsFrom() const { - return resolveNameReference(getInheritString()); + return hasInheritString() ? resolveNameReference(getInheritString()) : nullptr; } /// Return true if this element has the given element as an inherited base, @@ -745,7 +745,7 @@ class MX_CORE_API Element : public std::enable_shared_from_this /// unique name for a child element. string createValidChildName(string name) const { - name = createValidName(name); + name = name.empty() ? "_" : createValidName(name); while (_childMap.count(name)) { name = incrementName(name); diff --git a/source/MaterialXCore/Interface.cpp b/source/MaterialXCore/Interface.cpp index 3a93a384c2..b733d3a4c7 100644 --- a/source/MaterialXCore/Interface.cpp +++ b/source/MaterialXCore/Interface.cpp @@ -305,7 +305,7 @@ InputPtr Input::getInterfaceInput() const { if (hasInterfaceName()) { - ConstNodeGraphPtr graph = getAncestorOfType(); + ConstGraphElementPtr graph = getAncestorOfType(); if (graph) { return graph->getInput(getInterfaceName()); diff --git a/source/MaterialXCore/Node.cpp b/source/MaterialXCore/Node.cpp index 45524b116d..9596d905bc 100644 --- a/source/MaterialXCore/Node.cpp +++ b/source/MaterialXCore/Node.cpp @@ -439,9 +439,7 @@ vector GraphElement::topologicalSort() const } } - size_t visitCount = 0; vector result; - while (!childQueue.empty()) { // Pop the queue and add to topological order. @@ -467,14 +465,6 @@ vector GraphElement::topologicalSort() const } } } - - visitCount++; - } - - // Check if there was a cycle. - if (visitCount != children.size()) - { - throw ExceptionFoundCycle("Encountered a cycle in graph: " + getName()); } return result; @@ -738,6 +728,25 @@ InterfaceElementPtr NodeGraph::getImplementation() const return nodedef ? nodedef->getImplementation() : InterfaceElementPtr(); } +vector NodeGraph::getDownstreamPorts() const +{ + vector downstreamPorts; + for (PortElementPtr port : getDocument()->getMatchingPorts(getQualifiedName(getName()))) + { + ElementPtr node = port->getParent(); + ElementPtr graph = node ? node->getParent() : nullptr; + if (graph && graph->isA() && graph == getParent()) + { + downstreamPorts.push_back(port); + } + } + std::sort(downstreamPorts.begin(), downstreamPorts.end(), [](const ConstElementPtr& a, const ConstElementPtr& b) + { + return a->getName() > b->getName(); + }); + return downstreamPorts; +} + bool NodeGraph::validate(string* message) const { bool res = true; diff --git a/source/MaterialXCore/Node.h b/source/MaterialXCore/Node.h index a316b0eb6c..55846cf2e3 100644 --- a/source/MaterialXCore/Node.h +++ b/source/MaterialXCore/Node.h @@ -308,7 +308,6 @@ class MX_CORE_API GraphElement : public InterfaceElement /// Return a vector of all children (nodes and outputs) sorted in /// topological order. - /// @throws ExceptionFoundCycle if a cycle is encountered. vector topologicalSort() const; /// If not yet present, add a geometry node to this graph matching the given property @@ -358,6 +357,14 @@ class MX_CORE_API NodeGraph : public GraphElement /// none was found. InterfaceElementPtr getImplementation() const; + /// @} + /// @name Traversal + /// @{ + + /// Return a vector of all downstream ports that connect to this graph, ordered by + /// the names of the port elements. + vector getDownstreamPorts() const; + /// @} /// @name Utility /// @{ diff --git a/source/MaterialXFormat/CMakeLists.txt b/source/MaterialXFormat/CMakeLists.txt index 940ef9662c..420149bae4 100644 --- a/source/MaterialXFormat/CMakeLists.txt +++ b/source/MaterialXFormat/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXFormat) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXFormat ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_FORMAT_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXFormat PROPERTIES - OUTPUT_NAME MaterialXFormat${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,26 +26,28 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXFormat + ${MATERIALX_MODULE_NAME} MaterialXCore ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXFormat +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXFormat - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXFormat/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXFormat.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXGenGlsl/CMakeLists.txt b/source/MaterialXGenGlsl/CMakeLists.txt index 2ddcb5475c..da497f9f88 100644 --- a/source/MaterialXGenGlsl/CMakeLists.txt +++ b/source/MaterialXGenGlsl/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXGenGlsl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXGenGlsl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_GENGLSL_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXGenGlsl PROPERTIES - OUTPUT_NAME MaterialXGenGlsl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,27 +26,29 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXGenGlsl + ${MATERIALX_MODULE_NAME} MaterialXGenShader MaterialXCore ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXGenGlsl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXGenGlsl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXGenGlsl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXGenGlsl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXGenMdl/CMakeLists.txt b/source/MaterialXGenMdl/CMakeLists.txt index b73e674b7f..d9991843ce 100644 --- a/source/MaterialXGenMdl/CMakeLists.txt +++ b/source/MaterialXGenMdl/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXGenMdl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXGenMdl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_GENMDL_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXGenMdl PROPERTIES - OUTPUT_NAME MaterialXGenMdl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,30 +26,32 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXGenMdl + ${MATERIALX_MODULE_NAME} MaterialXGenShader MaterialXCore ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXGenMdl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXGenMdl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXGenMdl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mdl - DESTINATION "${MATERIALX_INSTALL_MDL_MODULE_PATH}") + install(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/mdl + DESTINATION "${MATERIALX_INSTALL_MDL_MODULE_PATH}") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXGenMdl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXGenMsl/CMakeLists.txt b/source/MaterialXGenMsl/CMakeLists.txt index 31d2599531..8d6d009f50 100644 --- a/source/MaterialXGenMsl/CMakeLists.txt +++ b/source/MaterialXGenMsl/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXGenMsl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXGenMsl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_GENMSL_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXGenMsl PROPERTIES - OUTPUT_NAME MaterialXGenMsl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,27 +26,29 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXGenMsl + ${MATERIALX_MODULE_NAME} MaterialXGenShader MaterialXCore ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXGenMsl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXGenMsl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXGenMsl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXGenMsl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXGenOsl/CMakeLists.txt b/source/MaterialXGenOsl/CMakeLists.txt index 03e30de0c1..3cf7b93438 100644 --- a/source/MaterialXGenOsl/CMakeLists.txt +++ b/source/MaterialXGenOsl/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXGenOsl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXGenOsl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_GENOSL_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXGenOsl PROPERTIES - OUTPUT_NAME MaterialXGenOsl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,28 +26,29 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXGenOsl + ${MATERIALX_MODULE_NAME} MaterialXGenShader MaterialXCore ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXGenOsl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXGenOsl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) - -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXGenOsl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXGenOsl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXGenShader/CMakeLists.txt b/source/MaterialXGenShader/CMakeLists.txt index 231dda6e5c..1b9533e0a5 100644 --- a/source/MaterialXGenShader/CMakeLists.txt +++ b/source/MaterialXGenShader/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXGenShader) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXGenShader ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_GENSHADER_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXGenShader PROPERTIES - OUTPUT_NAME MaterialXGenShader${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,30 +26,32 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXGenShader + ${MATERIALX_MODULE_NAME} MaterialXCore MaterialXFormat ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXGenShader +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXGenShader - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXGenShader/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXGenShader.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../../resources" - DESTINATION . MESSAGE_NEVER) + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../../resources" + DESTINATION . MESSAGE_NEVER) +endif() diff --git a/source/MaterialXGenShader/ShaderGraph.cpp b/source/MaterialXGenShader/ShaderGraph.cpp index e6ad6eca29..8a424f8bf5 100644 --- a/source/MaterialXGenShader/ShaderGraph.cpp +++ b/source/MaterialXGenShader/ShaderGraph.cpp @@ -1225,12 +1225,6 @@ void ShaderGraph::topologicalSort() } } } - - // Check if there was a cycle. - if (count != _nodeMap.size()) - { - throw ExceptionFoundCycle("Encountered a cycle in graph: " + getName()); - } } void ShaderGraph::setVariableNames(GenContext& context) diff --git a/source/MaterialXGenShader/ShaderGraph.h b/source/MaterialXGenShader/ShaderGraph.h index 4e30c4ae66..4117599c27 100644 --- a/source/MaterialXGenShader/ShaderGraph.h +++ b/source/MaterialXGenShader/ShaderGraph.h @@ -103,7 +103,6 @@ class MX_GENSHADER_API ShaderGraph : public ShaderNode void addDefaultGeomNode(ShaderInput* input, const GeomPropDef& geomprop, GenContext& context); /// Sort the nodes in topological order. - /// @throws ExceptionFoundCycle if a cycle is encountered. void topologicalSort(); /// Return an iterator for traversal upstream from the given output diff --git a/source/MaterialXGenShader/ShaderNode.cpp b/source/MaterialXGenShader/ShaderNode.cpp index c923e4be57..3eb750f1ff 100644 --- a/source/MaterialXGenShader/ShaderNode.cpp +++ b/source/MaterialXGenShader/ShaderNode.cpp @@ -381,7 +381,17 @@ void ShaderNode::initialize(const Node& node, const NodeDef& nodeDef, GenContext ShaderInput* input = getInput(nodeValue->getName()); if (input) { - input->setPath(nodeValue->getNamePath()); + string path = nodeValue->getNamePath(); + InputPtr nodeInput = nodeValue->asA(); + if (nodeInput) + { + InputPtr interfaceInput = nodeInput->getInterfaceInput(); + if (interfaceInput) + { + path = interfaceInput->getNamePath(); + } + } + input->setPath(path); } } diff --git a/source/MaterialXGraphEditor/Graph.cpp b/source/MaterialXGraphEditor/Graph.cpp index 9e3fbccc40..801a7e09aa 100644 --- a/source/MaterialXGraphEditor/Graph.cpp +++ b/source/MaterialXGraphEditor/Graph.cpp @@ -84,7 +84,6 @@ Graph::Graph(const std::string& materialFilename, _geomFilter.push_back(".gltf"); _graphDoc = loadDocument(materialFilename); - _graphDoc->importLibrary(_stdLib); _initial = true; createNodeUIList(_stdLib); @@ -177,6 +176,7 @@ mx::DocumentPtr Graph::loadDocument(mx::FilePath filename) if (!filename.isEmpty()) { mx::readFromXmlFile(doc, filename, _searchPath, &readOptions); + doc->importLibrary(_stdLib); std::string message; if (!doc->validate(&message)) { @@ -570,7 +570,7 @@ ImVec2 Graph::layoutPosition(UiNodePtr layoutNode, ImVec2 startingPos, bool init UiNodePtr nextNode = layoutNode->getConnectedNode(pins[i]->_name); if (nextNode) { - startingPos.x = (1200.f - ((layoutNode->_level) * 350)) * _fontScale; + startingPos.x = (1200.f - ((layoutNode->_level) * 250)) * _fontScale; ed::SetNodePosition(layoutNode->getId(), startingPos); layoutNode->setPos(ImVec2(startingPos)); // call layout position on upstream node with newPos as -140 to the left of current node @@ -581,7 +581,7 @@ ImVec2 Graph::layoutPosition(UiNodePtr layoutNode, ImVec2 startingPos, bool init } else { - startingPos.x = (1200.f - ((layoutNode->_level) * 350)) * _fontScale; + startingPos.x = (1200.f - ((layoutNode->_level) * 250)) * _fontScale; layoutNode->setPos(ImVec2(startingPos)); // set current node position ed::SetNodePosition(layoutNode->getId(), ImVec2(startingPos)); @@ -644,8 +644,8 @@ void Graph::setPinColor() _pinColor.insert(std::make_pair("BSDF", ImColor(10, 181, 150, 255))); _pinColor.insert(std::make_pair("EDF", ImColor(255, 50, 100, 255))); _pinColor.insert(std::make_pair("VDF", ImColor(0, 100, 151, 255))); - _pinColor.insert(std::make_pair("surfaceshader", ImColor(150, 255, 255, 255))); - _pinColor.insert(std::make_pair("material", ImColor(255, 255, 255, 255))); + _pinColor.insert(std::make_pair(mx::SURFACE_SHADER_TYPE_STRING, ImColor(150, 255, 255, 255))); + _pinColor.insert(std::make_pair(mx::MATERIAL_TYPE_STRING, ImColor(255, 255, 255, 255))); _pinColor.insert(std::make_pair(mx::DISPLACEMENT_SHADER_TYPE_STRING, ImColor(155, 50, 100, 255))); _pinColor.insert(std::make_pair(mx::VOLUME_SHADER_TYPE_STRING, ImColor(155, 250, 100, 255))); _pinColor.insert(std::make_pair(mx::LIGHT_SHADER_TYPE_STRING, ImColor(100, 150, 100, 255))); @@ -701,8 +701,13 @@ void Graph::selectMaterial(UiNodePtr uiNode) // set the node to display in render veiw based off the selected node or nodegraph void Graph::setRenderMaterial(UiNodePtr node) { - // set render node right away is node is a material - if (node->getNode() && node->getNode()->getType() == "material") + // For now surface shaders and materials are considered renderable. + // This can be adjusted as desired to include being able to use outputs, + // and / a sub-graph in the nodegraph. + const mx::StringSet RENDERABLE_TYPES = { mx::MATERIAL_TYPE_STRING, mx::SURFACE_SHADER_TYPE_STRING }; + + // set render node right away is node is renderable + if (node->getNode() && RENDERABLE_TYPES.count(node->getNode()->getType())) { // only set new render node if different material has been selected if (_currRenderNode != node) @@ -712,55 +717,123 @@ void Graph::setRenderMaterial(UiNodePtr node) _renderer->setMaterialCompilation(true); } } + + // Traverse downstream looking for the first renderable element. else { - // continue downstream using output connections until a material node is found - std::vector outNodes = node->getOutputConnections(); - if (outNodes.size() > 0) + mx::NodePtr mtlxNode = node->getNode(); + mx::NodeGraphPtr mtlxNodeGraph = node->getNodeGraph(); + mx::OutputPtr mtlxOutput = node->getOutput(); + if (mtlxOutput) + { + mx::ElementPtr parent = mtlxOutput->getParent(); + if (parent->isA()) + mtlxNodeGraph = parent->asA(); + else if (parent->isA()) + mtlxNode = parent->asA(); + } + mx::StringSet testPaths; + if (mtlxNode) + { + mx::ElementPtr parent = mtlxNode->getParent(); + if (parent->isA()) + { + // There is no logic to support traversing from inside a functional graph + // to it's instance and hence downstream so skip this from consideration. + // The closest approach would be to "flatten" all definitions to compound graphs. + mx::NodeGraphPtr parentGraph = parent->asA(); + if (parentGraph->getNodeDef()) + { + return; + } + } + testPaths.insert(mtlxNode->getNamePath()); + } + else if (mtlxNodeGraph) { - if (outNodes[0]->getNode()) + testPaths.insert(mtlxNodeGraph->getNamePath()); + } + + mx::NodePtr foundNode = nullptr; + while (!testPaths.empty() && !foundNode) + { + mx::StringSet nextPaths; + for (const std::string& testPath : testPaths) { - if (outNodes[0]->getNode()->getType() == mx::SURFACE_SHADER_TYPE_STRING) + mx::ElementPtr testElem = _graphDoc->getDescendant(testPath); + mx::NodePtr testNode = testElem->asA(); + std::vector downstreamPorts; + if (testNode) + { + downstreamPorts = testNode->getDownstreamPorts(); + } + else + { + mx::NodeGraphPtr testGraph = testElem->asA(); + if (testGraph) + { + downstreamPorts = testGraph->getDownstreamPorts(); + } + } + // Test all downstream ports. If the port's node is renderable + // then stop searching. + for (mx::PortElementPtr downstreamPort : downstreamPorts) { - std::vector shaderOut = outNodes[0]->getOutputConnections(); - if (shaderOut.size() > 0) + mx::ElementPtr parent = downstreamPort->getParent(); + if (parent) { - if (shaderOut[0]) + mx::NodePtr downstreamNode = parent->asA(); + if (downstreamNode) { - if (shaderOut[0]->getNode()->getType() == "material") + mx::NodeDefPtr nodeDef = downstreamNode->getNodeDef(); + if (nodeDef) { - if (_currRenderNode != shaderOut[0]) + if (RENDERABLE_TYPES.count(nodeDef->getType())) { - _currRenderNode = shaderOut[0]; - _frameCount = ImGui::GetFrameCount(); - _renderer->setMaterialCompilation(true); + foundNode = downstreamNode; + break; } } } + if (!foundNode) + { + nextPaths.insert(parent->getNamePath()); + } } - else - { - _currRenderNode = nullptr; - } } - else if (outNodes[0]->getNode()->getType() == mx::MATERIAL_TYPE_STRING) + if (foundNode) + { + break; + } + } + + // Set up next set of nodes to search downstream + testPaths = nextPaths; + } + + // Update rendering. If found use that node, otherwise + // use the current fallback of using the first renderable node. + if (foundNode) + { + for (auto uiNode : _graphNodes) + { + if (uiNode->getNode() == foundNode) { - if (_currRenderNode != outNodes[0]) + if (_currRenderNode != uiNode) { - _currRenderNode = outNodes[0]; + _currRenderNode = uiNode; _frameCount = ImGui::GetFrameCount(); _renderer->setMaterialCompilation(true); } + break; } } - else - { - _currRenderNode = nullptr; - } } else { _currRenderNode = nullptr; + _frameCount = ImGui::GetFrameCount(); + _renderer->setMaterialCompilation(true); } } } @@ -768,38 +841,15 @@ void Graph::setRenderMaterial(UiNodePtr node) void Graph::updateMaterials(mx::InputPtr input, mx::ValuePtr value) { std::string renderablePath; - mx::TypedElementPtr renderableElem; - std::vector elems = mx::findRenderableElements(_graphDoc); - - size_t num = 0; - int num2 = 0; - for (mx::TypedElementPtr elem : elems) + if (_currRenderNode) { - renderableElem = elem; - mx::NodePtr node = elem->asA(); - if (node) + if (_currRenderNode->getNode()) { - if (_currRenderNode) - { - if (node->getName() == _currRenderNode->getName()) - { - renderablePath = renderableElem->getNamePath(); - break; - } - } - else - { - renderablePath = renderableElem->getNamePath(); - } + renderablePath = _currRenderNode->getNode()->getNamePath(); } - else + else if (_currRenderNode->getOutput()) { - renderablePath = renderableElem->getNamePath(); - if (num2 == 2) - { - break; - } - num2++; + renderablePath = _currRenderNode->getOutput()->getNamePath(); } } @@ -821,16 +871,10 @@ void Graph::updateMaterials(mx::InputPtr input, mx::ValuePtr value) else { std::string name = input->getNamePath(); - // need to use exact interface name in order for input - mx::InputPtr interfaceInput = findInput(input, input->getName()); - if (interfaceInput) - { - name = interfaceInput->getNamePath(); - } // Note that if there is a topogical change due to // this value change or a transparency change, then // this is not currently caught here. - _renderer->getMaterials()[num]->modifyUniform(name, value); + _renderer->getMaterials()[0]->modifyUniform(name, value); } } } @@ -1018,6 +1062,7 @@ void Graph::setConstant(UiNodePtr node, mx::InputPtr& input, const mx::UIPropert ImGui::PushItemWidth(-100); if (ImGui::Button("Browse")) { + _fileDialogImageInputName = input->getName(); _fileDialogImage.setTitle("Node Input Dialog"); _fileDialogImage.open(); _fileDialogImage.setTypeFilters(_imageFilter); @@ -1029,7 +1074,7 @@ void Graph::setConstant(UiNodePtr node, mx::InputPtr& input, const mx::UIPropert ImGui::PopStyleColor(); // create and load document from selected file - if (_fileDialogImage.hasSelected()) + if (_fileDialogImage.hasSelected() && _fileDialogImageInputName == input->getName()) { // set the new filename to the complete file path mx::FilePath fileName = _fileDialogImage.getSelected(); @@ -1038,6 +1083,7 @@ void Graph::setConstant(UiNodePtr node, mx::InputPtr& input, const mx::UIPropert input->setAttribute(input->FILE_PREFIX_ATTRIBUTE, ""); _fileDialogImage.clearSelected(); _fileDialogImage.setTypeFilters(std::vector()); + _fileDialogImageInputName = ""; } // set input value and update materials if different from previous value @@ -2741,7 +2787,7 @@ void Graph::deleteNode(UiNodePtr node) { mx::NodeDefPtr nodeDef = pin->_pinNode->getNode()->getNodeDef(pin->_pinNode->getNode()->getName()); val = nodeDef->getActiveInput(pin->_input->getName())->getValue(); - if (pin->_pinNode->getNode()->getType() == "surfaceshader") + if (pin->_pinNode->getNode()->getType() == mx::SURFACE_SHADER_TYPE_STRING) { pin->_input->setConnectedOutput(nullptr); } @@ -3714,17 +3760,10 @@ void Graph::drawGraph(ImVec2 mousePos) _currUiNode = _graphNodes[graphPos]; // update render material if needed if (_currUiNode->getNode()) - { - if (_currUiNode->getNode()->getType() == mx::SURFACE_SHADER_TYPE_STRING || _currUiNode->getNode()->getType() == mx::MATERIAL_TYPE_STRING) - { - setRenderMaterial(_currUiNode); - } - } - else if (_currUiNode->getNodeGraph()) { setRenderMaterial(_currUiNode); } - else if (_currUiNode->getOutput()) + else if (_currUiNode->getNodeGraph() || _currUiNode->getOutput()) { setRenderMaterial(_currUiNode); } @@ -3796,11 +3835,11 @@ void Graph::drawGraph(ImVec2 mousePos) linkGraph(); ImVec2 canvasPos = ed::ScreenToCanvas(mousePos); // place the copied nodes or the individual new nodes - if ((int) _copiedNodes.size() > 0) + if (!_copiedNodes.empty()) { positionPasteBin(canvasPos); } - else + else if (!_graphNodes.empty()) { ed::SetNodePosition(_graphNodes.back()->getId(), canvasPos); } @@ -4057,7 +4096,6 @@ void Graph::drawGraph(ImVec2 mousePos) std::string graphName = fileName.getBaseName(); _currGraphName.push_back(graphName.substr(0, graphName.length() - 5)); _graphDoc = loadDocument(fileName); - _graphDoc->importLibrary(_stdLib); _initial = true; buildUiBaseGraph(_graphDoc); diff --git a/source/MaterialXGraphEditor/Graph.h b/source/MaterialXGraphEditor/Graph.h index 68140cdaae..f01e45fe35 100644 --- a/source/MaterialXGraphEditor/Graph.h +++ b/source/MaterialXGraphEditor/Graph.h @@ -214,7 +214,7 @@ class Graph FileDialog _fileDialogSave; FileDialog _fileDialogImage; FileDialog _fileDialogGeom; - + std::string _fileDialogImageInputName; bool _isNodeGraph; diff --git a/source/MaterialXGraphEditor/RenderView.cpp b/source/MaterialXGraphEditor/RenderView.cpp index faf48f543a..176014ba65 100644 --- a/source/MaterialXGraphEditor/RenderView.cpp +++ b/source/MaterialXGraphEditor/RenderView.cpp @@ -159,7 +159,6 @@ RenderView::RenderView(mx::DocumentPtr doc, _genContext(mx::GlslShaderGenerator::create()), _unitRegistry(mx::UnitConverterRegistry::create()), _splitByUdims(true), - _mergeMaterials(false), _materialCompilation(false), _renderTransparency(true), _renderDoubleSided(true), @@ -410,18 +409,15 @@ void RenderView::updateMaterials(mx::TypedElementPtr typedElem) // Clear user data on the generator. _genContext.clearUserData(); - // Clear materials if merging is not requested. - if (!_mergeMaterials) + // Clear materials. + for (mx::MeshPartitionPtr geom : _geometryList) { - for (mx::MeshPartitionPtr geom : _geometryList) + if (_materialAssignments.count(geom)) { - if (_materialAssignments.count(geom)) - { - assignMaterial(geom, nullptr); - } + assignMaterial(geom, nullptr); } - _materials.clear(); } + _materials.clear(); std::vector newMaterials; try @@ -434,10 +430,19 @@ void RenderView::updateMaterials(mx::TypedElementPtr typedElem) // Apply direct lights. applyDirectLights(_document); - //// Check for any udim set. + // Check for any udim set. mx::ValuePtr udimSetValue = _document->getGeomPropValue(mx::UDIM_SET_PROPERTY); - //// Create new materials. + // Skip material nodes without upstream shaders. + mx::NodePtr node = typedElem ? typedElem->asA() : nullptr; + if (node && + node->getCategory() == mx::SURFACE_MATERIAL_NODE_STRING && + mx::getShaderNodes(node).empty()) + { + typedElem = nullptr; + } + + // Create new materials. if (!typedElem) { std::vector elems = mx::findRenderableElements(_document); @@ -451,8 +456,7 @@ void RenderView::updateMaterials(mx::TypedElementPtr typedElem) mx::NodePtr materialNode = nullptr; if (typedElem) { - mx::NodePtr node = typedElem->asA(); - materialNode = node && node->getType() == mx::MATERIAL_TYPE_STRING ? node : nullptr; + materialNode = node; if (udimSetValue && udimSetValue->isA()) { for (const std::string& udim : udimSetValue->asA()) @@ -551,14 +555,11 @@ void RenderView::updateMaterials(mx::TypedElementPtr typedElem) // Apply fallback assignments. mx::GlslMaterialPtr fallbackMaterial = newMaterials[0]; - if (!_mergeMaterials || fallbackMaterial->getUdim().empty()) + for (mx::MeshPartitionPtr geom : _geometryList) { - for (mx::MeshPartitionPtr geom : _geometryList) + if (!_materialAssignments[geom]) { - if (!_materialAssignments[geom]) - { - assignMaterial(geom, fallbackMaterial); - } + assignMaterial(geom, fallbackMaterial); } } @@ -720,7 +721,7 @@ void RenderView::loadEnvironmentLight() envIrradianceMap = _imageHandler->acquireImage(envIrradiancePath); // If not found, then generate an irradiance map via spherical harmonics. - if (envIrradianceMap == _imageHandler->getInvalidImage()) + if (envIrradianceMap == _imageHandler->getZeroImage()) { mx::Sh3ColorCoeffs shIrradiance = mx::projectEnvironment(envRadianceMap, true); envIrradianceMap = mx::renderEnvironment(shIrradiance, IRRADIANCE_MAP_WIDTH, IRRADIANCE_MAP_HEIGHT); diff --git a/source/MaterialXGraphEditor/RenderView.h b/source/MaterialXGraphEditor/RenderView.h index e931be9592..354e898ce1 100644 --- a/source/MaterialXGraphEditor/RenderView.h +++ b/source/MaterialXGraphEditor/RenderView.h @@ -145,11 +145,6 @@ class RenderView return _materialAssignments; } - bool getMergeMaterials() - { - return _mergeMaterials; - } - std::vector getMaterials() { return _materials; @@ -323,7 +318,6 @@ class RenderView bool _splitByUdims; // Material options - bool _mergeMaterials; bool _materialCompilation; // Unit options diff --git a/source/MaterialXRender/CMakeLists.txt b/source/MaterialXRender/CMakeLists.txt index d0a50232cd..52d07e688e 100644 --- a/source/MaterialXRender/CMakeLists.txt +++ b/source/MaterialXRender/CMakeLists.txt @@ -1,3 +1,5 @@ +set(MATERIALX_MODULE_NAME MaterialXRender) + include_directories( ${EXTERNAL_INCLUDE_DIRS} ${CMAKE_CURRENT_SOURCE_DIR}/../) @@ -18,12 +20,18 @@ if(UNIX) add_compile_options(-Wno-unused-function) endif() -add_library(MaterialXRender ${materialx_source} ${materialx_headers} ${materialx_inlined}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers} ${materialx_inlined}) add_definitions(-DMATERIALX_RENDER_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + target_link_libraries( - MaterialXRender + ${MATERIALX_MODULE_NAME} MaterialXGenShader ${CMAKE_DL_LIBS}) @@ -33,7 +41,7 @@ if(MATERIALX_BUILD_OIIO) find_package(OpenImageIO REQUIRED) if(OPENIMAGEIO_FOUND) include_directories(${OPENIMAGEIO_INCLUDE_DIR}) - target_link_libraries(MaterialXRender ${OPENIMAGEIO_LIBRARIES}) + target_link_libraries(${MATERIALX_MODULE_NAME} ${OPENIMAGEIO_LIBRARIES}) # Also needed by MaterialXTest: set(OPENIMAGEIO_FOUND "${OPENIMAGEIO_FOUND}" PARENT_SCOPE) set(OPENIMAGEIO_INCLUDE_DIR "${OPENIMAGEIO_INCLUDE_DIR}" PARENT_SCOPE) @@ -44,25 +52,27 @@ if(MATERIALX_BUILD_OIIO) endif() set_target_properties( - MaterialXRender PROPERTIES - OUTPUT_NAME MaterialXRender${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" VERSION "${MATERIALX_LIBRARY_VERSION}" SOVERSION "${MATERIALX_MAJOR_VERSION}") -install(TARGETS MaterialXRender - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXRender/ MESSAGE_NEVER - FILES_MATCHING - PATTERN "*.h*" - PATTERN "*.inl") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING + PATTERN "*.h*" + PATTERN "*.inl") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXRender.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXRender/External/OpenImageIO/FindOpenImageIO.cmake b/source/MaterialXRender/External/OpenImageIO/FindOpenImageIO.cmake index 4fab4f9814..6c1b1682d6 100644 --- a/source/MaterialXRender/External/OpenImageIO/FindOpenImageIO.cmake +++ b/source/MaterialXRender/External/OpenImageIO/FindOpenImageIO.cmake @@ -45,6 +45,13 @@ find_library ( OPENIMAGEIO_LIBRARY HINTS ${OPENIMAGEIO_ROOT_DIR}/lib PATH_SUFFIXES lib64 lib PATHS "${OPENIMAGEIO_ROOT_DIR}/lib" ) + +find_library ( OPENIMAGEIO_UTIL_LIBRARY + NAMES OpenImageIO_Util${OIIO_LIBNAME_SUFFIX} + HINTS ${OPENIMAGEIO_ROOT_DIR}/lib + PATH_SUFFIXES lib64 lib + PATHS "${OPENIMAGEIO_ROOT_DIR}/lib" ) + find_path ( OPENIMAGEIO_INCLUDE_DIR NAMES OpenImageIO/imageio.h HINTS ${OPENIMAGEIO_ROOT_DIR}/include @@ -66,7 +73,7 @@ if (EXISTS "${OIIO_VERSION_HEADER}") set (OPENIMAGEIO_VERSION "${OPENIMAGEIO_VERSION_MAJOR}.${OPENIMAGEIO_VERSION_MINOR}.${OPENIMAGEIO_VERSION_PATCH}") endif () -set ( OPENIMAGEIO_LIBRARIES ${OPENIMAGEIO_LIBRARY}) +set ( OPENIMAGEIO_LIBRARIES ${OPENIMAGEIO_LIBRARY} ${OPENIMAGEIO_UTIL_LIBRARY}) get_filename_component (OPENIMAGEIO_LIBRARY_DIRS "${OPENIMAGEIO_LIBRARY}" DIRECTORY CACHE) if (NOT OpenImageIO_FIND_QUIETLY) diff --git a/source/MaterialXRender/ImageHandler.cpp b/source/MaterialXRender/ImageHandler.cpp index bc43b617ff..d54a18fedd 100644 --- a/source/MaterialXRender/ImageHandler.cpp +++ b/source/MaterialXRender/ImageHandler.cpp @@ -56,9 +56,6 @@ ImageHandler::ImageHandler(ImageLoaderPtr imageLoader) { addLoader(imageLoader); _zeroImage = createUniformImage(2, 2, 4, Image::BaseType::UINT8, Color4(0.0f)); - - // Generated shaders interpret 1x1 textures as invalid images. - _invalidImage = createUniformImage(1, 1, 4, Image::BaseType::UINT8, Color4(0.0f)); } void ImageHandler::addLoader(ImageLoaderPtr loader) @@ -118,7 +115,7 @@ bool ImageHandler::saveImage(const FilePath& filePath, return false; } -ImagePtr ImageHandler::acquireImage(const FilePath& filePath) +ImagePtr ImageHandler::acquireImage(const FilePath& filePath, const Color4& defaultColor) { // Resolve the input filepath. FilePath resolvedFilePath = filePath; @@ -142,9 +139,12 @@ ImagePtr ImageHandler::acquireImage(const FilePath& filePath) return image; } - // No valid image was found, so cache the sentinel invalid image. - cacheImage(resolvedFilePath, _invalidImage); - return _invalidImage; + // No valid image was found, so generate a uniform texture with the given default color. + // TODO: This step assumes that the missing image and its default color are in the same + // color space, which is not always the case. + ImagePtr defaultImage = createUniformImage(1, 1, 4, Image::BaseType::UINT8, defaultColor); + cacheImage(resolvedFilePath, defaultImage); + return defaultImage; } bool ImageHandler::bindImage(ImagePtr, const ImageSamplingProperties&) @@ -189,7 +189,7 @@ ImageVec ImageHandler::getReferencedImages(ConstDocumentPtr doc) if (file) { ImagePtr image = acquireImage(file->getResolvedValueString()); - if (image && image != _invalidImage) + if (image) { imageVec.push_back(image); } @@ -214,14 +214,6 @@ ImagePtr ImageHandler::loadImage(const FilePath& filePath) } if (image) { - // Generated shaders interpret 1x1 textures as invalid images, so valid 1x1 - // images must be resized. - if (image->getWidth() == 1 && image->getHeight() == 1) - { - image = createUniformImage(2, 2, image->getChannelCount(), - image->getBaseType(), image->getTexelColor(0, 0)); - } - return image; } } @@ -288,23 +280,23 @@ void ImageSamplingProperties::setProperties(const string& fileNameUniform, root = root.substr(0, pos); } - const string uaddressmodeStr = root + UADDRESS_MODE_SUFFIX; - const ShaderPort* port = uniformBlock.find(uaddressmodeStr); + const ShaderPort* port = uniformBlock.find(root + UADDRESS_MODE_SUFFIX); ValuePtr intValue = port ? port->getValue() : nullptr; uaddressMode = ImageSamplingProperties::AddressMode(intValue && intValue->isA() ? intValue->asA() : INVALID_MAPPED_INT_VALUE); - const string vaddressmodeStr = root + VADDRESS_MODE_SUFFIX; - port = uniformBlock.find(vaddressmodeStr); + port = uniformBlock.find(root + VADDRESS_MODE_SUFFIX); intValue = port ? port->getValue() : nullptr; vaddressMode = ImageSamplingProperties::AddressMode(intValue && intValue->isA() ? intValue->asA() : INVALID_MAPPED_INT_VALUE); - const string filtertypeStr = root + FILTER_TYPE_SUFFIX; - port = uniformBlock.find(filtertypeStr); + port = uniformBlock.find(root + FILTER_TYPE_SUFFIX); intValue = port ? port->getValue() : nullptr; filterType = ImageSamplingProperties::FilterType(intValue && intValue->isA() ? intValue->asA() : INVALID_MAPPED_INT_VALUE); - const string defaultColorStr = root + DEFAULT_COLOR_SUFFIX; - port = uniformBlock.find(defaultColorStr); + port = uniformBlock.find(root + DEFAULT_COLOR_SUFFIX); + if (!port) + { + port = uniformBlock.find(root + DEFAULT_COLOR_SUFFIX + "_cm_in"); + } ValuePtr colorValue = port ? port->getValue() : nullptr; if (colorValue) { diff --git a/source/MaterialXRender/ImageHandler.h b/source/MaterialXRender/ImageHandler.h index ee1fe127c4..c744eb2f6a 100644 --- a/source/MaterialXRender/ImageHandler.h +++ b/source/MaterialXRender/ImageHandler.h @@ -188,7 +188,7 @@ class MX_RENDER_API ImageHandler /// found in the cache, then each image loader will be applied in turn. /// @param filePath File path of the image. /// @return On success, a shared pointer to the acquired image. - ImagePtr acquireImage(const FilePath& filePath); + ImagePtr acquireImage(const FilePath& filePath, const Color4& defaultColor = Color4(0.0f)); /// Bind an image for rendering. /// @param image The image to bind. @@ -247,13 +247,6 @@ class MX_RENDER_API ImageHandler return _zeroImage; } - /// Return the sentinel invalid image, representing images that cannot be loaded - /// and should be replaced with their declared default value. - ImagePtr getInvalidImage() const - { - return _invalidImage; - } - /// Acquire all images referenced by the given document, and return the /// images in a vector. ImageVec getReferencedImages(ConstDocumentPtr doc); @@ -278,7 +271,6 @@ class MX_RENDER_API ImageHandler FileSearchPath _searchPath; StringResolverPtr _resolver; ImagePtr _zeroImage; - ImagePtr _invalidImage; }; MATERIALX_NAMESPACE_END diff --git a/source/MaterialXRender/ShaderRenderer.cpp b/source/MaterialXRender/ShaderRenderer.cpp index a5e81d1f68..b621e5cd88 100644 --- a/source/MaterialXRender/ShaderRenderer.cpp +++ b/source/MaterialXRender/ShaderRenderer.cpp @@ -25,17 +25,26 @@ const float DEFAULT_FAR_PLANE = 100.0f; // ShaderRenderer methods // -ShaderRenderer::ShaderRenderer(unsigned int width, unsigned int height, Image::BaseType baseType) : +ShaderRenderer::ShaderRenderer(unsigned int width, unsigned int height, Image::BaseType baseType, MatrixConvention matrixConvention) : _width(width), _height(height), - _baseType(baseType) + _baseType(baseType), + _matrixConvention(matrixConvention) { // Initialize a default camera. float fH = std::tan(DEFAULT_FIELD_OF_VIEW / 360.0f * PI) * DEFAULT_NEAR_PLANE; float fW = fH * 1.0f; _camera = Camera::create(); _camera->setViewMatrix(Camera::createViewMatrix(DEFAULT_EYE_POSITION, DEFAULT_TARGET_POSITION, DEFAULT_UP_VECTOR)); - _camera->setProjectionMatrix(Camera::createPerspectiveMatrix(-fW, fW, -fH, fH, DEFAULT_NEAR_PLANE, DEFAULT_FAR_PLANE)); + + if (_matrixConvention == ShaderRenderer::MatrixConvention::Metal) + { + _camera->setProjectionMatrix(Camera::createPerspectiveMatrixZP(-fW, fW, -fH, fH, DEFAULT_NEAR_PLANE, DEFAULT_FAR_PLANE)); + } + else // MatrixConvention::OpenGL (default) + { + _camera->setProjectionMatrix(Camera::createPerspectiveMatrix(-fW, fW, -fH, fH, DEFAULT_NEAR_PLANE, DEFAULT_FAR_PLANE)); + } } void ShaderRenderer::createProgram(ShaderPtr) diff --git a/source/MaterialXRender/ShaderRenderer.h b/source/MaterialXRender/ShaderRenderer.h index 2c6f5fbf87..b049f81126 100644 --- a/source/MaterialXRender/ShaderRenderer.h +++ b/source/MaterialXRender/ShaderRenderer.h @@ -30,6 +30,12 @@ using ShaderRendererPtr = std::shared_ptr; class MX_RENDER_API ShaderRenderer { public: + /// Viewing API matrix conventions designation (default to OpenGL). + enum class MatrixConvention + { + OpenGL = 0, + Metal = 1 + }; /// A map with name and source code for each shader stage. using StageMap = StringMap; @@ -123,13 +129,16 @@ class MX_RENDER_API ShaderRenderer /// @} protected: - ShaderRenderer(unsigned int width, unsigned int height, Image::BaseType baseType); + ShaderRenderer(unsigned int width, unsigned int height, Image::BaseType baseType, + MatrixConvention matrixConvention = MatrixConvention::OpenGL); protected: unsigned int _width; unsigned int _height; Image::BaseType _baseType; + MatrixConvention _matrixConvention; + CameraPtr _camera; ImageHandlerPtr _imageHandler; GeometryHandlerPtr _geometryHandler; diff --git a/source/MaterialXRenderGlsl/CMakeLists.txt b/source/MaterialXRenderGlsl/CMakeLists.txt index ddab96c318..cb2f3c27c2 100644 --- a/source/MaterialXRenderGlsl/CMakeLists.txt +++ b/source/MaterialXRenderGlsl/CMakeLists.txt @@ -1,3 +1,5 @@ +set(MATERIALX_MODULE_NAME MaterialXRenderGlsl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.c*") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") @@ -34,12 +36,18 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") add_compile_options(-Wno-deprecated-declarations) endif() -add_library(MaterialXRenderGlsl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_RENDERGLSL_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + if(MATERIALX_BUILD_SHARED_LIBS) - target_compile_definitions(MaterialXRenderGlsl PUBLIC GLAD_GLAPI_EXPORT PRIVATE GLAD_GLAPI_EXPORT_BUILD) + target_compile_definitions(${MATERIALX_MODULE_NAME} PUBLIC GLAD_GLAPI_EXPORT PRIVATE GLAD_GLAPI_EXPORT_BUILD) endif() set(COMMON_LIBRARIES @@ -50,19 +58,19 @@ set(COMMON_LIBRARIES if(WIN32) if(MSVC) target_link_libraries( - MaterialXRenderGlsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} Opengl32) elseif(MINGW) target_link_libraries( - MaterialXRenderGlsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} Opengl32 gdi32) endif() elseif(APPLE) target_link_libraries( - MaterialXRenderGlsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} ${OPENGL_LIBRARIES} "-framework Foundation" @@ -70,7 +78,7 @@ elseif(APPLE) "-framework Metal") elseif(UNIX) target_link_libraries( - MaterialXRenderGlsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} ${OPENGL_LIBRARIES} ${X11_LIBRARIES} @@ -78,30 +86,32 @@ elseif(UNIX) endif() set_target_properties( - MaterialXRenderGlsl PROPERTIES - OUTPUT_NAME MaterialXRenderGlsl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" VERSION "${MATERIALX_LIBRARY_VERSION}" SOVERSION "${MATERIALX_MAJOR_VERSION}") -target_include_directories(MaterialXRenderGlsl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXRenderGlsl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXRenderGlsl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXRenderGlsl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXRenderGlsl/GlslMaterial.cpp b/source/MaterialXRenderGlsl/GlslMaterial.cpp index ef7a0ed0c2..ce4582d44f 100644 --- a/source/MaterialXRenderGlsl/GlslMaterial.cpp +++ b/source/MaterialXRenderGlsl/GlslMaterial.cpp @@ -209,7 +209,7 @@ ImagePtr GlslMaterial::bindImage(const FilePath& filePath, const std::string& un imageHandler->setFilenameResolver(resolver); // Acquire the given image. - ImagePtr image = imageHandler->acquireImage(filePath); + ImagePtr image = imageHandler->acquireImage(filePath, samplingProperties.defaultColor); if (!image) { return nullptr; diff --git a/source/MaterialXRenderGlsl/GlslProgram.cpp b/source/MaterialXRenderGlsl/GlslProgram.cpp index a60997716a..900cac0ef1 100644 --- a/source/MaterialXRenderGlsl/GlslProgram.cpp +++ b/source/MaterialXRenderGlsl/GlslProgram.cpp @@ -491,7 +491,7 @@ ImagePtr GlslProgram::bindTexture(unsigned int uniformType, int uniformLocation, uniformType >= GL_SAMPLER_1D && uniformType <= GL_SAMPLER_CUBE) { // Acquire the image. - ImagePtr image = imageHandler->acquireImage(filePath); + ImagePtr image = imageHandler->acquireImage(filePath, samplingProperties.defaultColor); if (imageHandler->bindImage(image, samplingProperties)) { GLTextureHandlerPtr textureHandler = std::static_pointer_cast(imageHandler); diff --git a/source/MaterialXRenderGlsl/GlslRenderer.cpp b/source/MaterialXRenderGlsl/GlslRenderer.cpp index e81ded996e..bf2c8cd849 100644 --- a/source/MaterialXRenderGlsl/GlslRenderer.cpp +++ b/source/MaterialXRenderGlsl/GlslRenderer.cpp @@ -25,7 +25,7 @@ GlslRendererPtr GlslRenderer::create(unsigned int width, unsigned int height, Im } GlslRenderer::GlslRenderer(unsigned int width, unsigned int height, Image::BaseType baseType) : - ShaderRenderer(width, height, baseType), + ShaderRenderer(width, height, baseType, MatrixConvention::OpenGL), _initialized(false), _screenColor(DEFAULT_SCREEN_COLOR_LIN_REC709) { diff --git a/source/MaterialXRenderHw/CMakeLists.txt b/source/MaterialXRenderHw/CMakeLists.txt index 85ef13c55c..dfd262a3ae 100644 --- a/source/MaterialXRenderHw/CMakeLists.txt +++ b/source/MaterialXRenderHw/CMakeLists.txt @@ -1,8 +1,12 @@ +set(MATERIALX_MODULE_NAME MaterialXRenderHw) + file(GLOB materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") if(APPLE) +if (NOT MATERIALX_BUILD_IOS) find_library(COCOA_FRAMEWORK Cocoa) +endif() file(GLOB materialx_source_oc "${CMAKE_CURRENT_SOURCE_DIR}/*.m") message("Objective C files: " ${materialx_source_oc}) set_source_files_properties(${materialx_source_oc} PROPERTIES @@ -20,26 +24,37 @@ endif() assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXRenderHw ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_RENDERHW_EXPORTS) +if(APPLE AND NOT MATERIALX_BUILD_IOS) +set(CMAKE_DL_LIBS +${CMAKE_DL_LIBS} +"-framework Cocoa") +endif() + +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + if(MSVC) target_link_libraries( - MaterialXRenderHw + ${MATERIALX_MODULE_NAME} MaterialXRender ${CMAKE_DL_LIBS}) elseif(APPLE) target_link_libraries( - MaterialXRenderHw + ${MATERIALX_MODULE_NAME} MaterialXRender ${CMAKE_DL_LIBS} "-framework Foundation" - "-framework Cocoa" "-framework Metal") elseif(UNIX) target_link_libraries( - MaterialXRenderHw + ${MATERIALX_MODULE_NAME} MaterialXRender ${CMAKE_DL_LIBS} ${X11_LIBRARIES} @@ -47,30 +62,32 @@ elseif(UNIX) endif() set_target_properties( - MaterialXRenderHw PROPERTIES - OUTPUT_NAME MaterialXRenderHw${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" VERSION "${MATERIALX_LIBRARY_VERSION}" SOVERSION "${MATERIALX_MAJOR_VERSION}") -target_include_directories(MaterialXRenderHw +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXRenderHw - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXRenderHw/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXRenderHw.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXRenderHw/SimpleWindowIOS.cpp b/source/MaterialXRenderHw/SimpleWindowIOS.cpp new file mode 100644 index 0000000000..1d4189b2ab --- /dev/null +++ b/source/MaterialXRenderHw/SimpleWindowIOS.cpp @@ -0,0 +1,40 @@ +// +// Copyright Contributors to the MaterialX Project +// SPDX-License-Identifier: Apache-2.0 +// + +#if defined(__APPLE__) + +#ifdef TARGET_OS_IOS + +#include + +MATERIALX_NAMESPACE_BEGIN + +SimpleWindow::SimpleWindow() : + _width(0), + _height(0) +{ + // Give a unique identifier to this window. + static unsigned int windowCount = 1; + _id = windowCount; + windowCount++; +} + +bool SimpleWindow::initialize(const char* title, + unsigned int width, unsigned int height, + void* /*applicationShell*/) +{ + _windowWrapper = WindowWrapper::create(nullptr); + return true; +} + +SimpleWindow::~SimpleWindow() +{ +} + +MATERIALX_NAMESPACE_END + +#endif + +#endif diff --git a/source/MaterialXRenderHw/SimpleWindowMac.cpp b/source/MaterialXRenderHw/SimpleWindowMac.cpp index 1cf070ac74..a04d1f49ae 100644 --- a/source/MaterialXRenderHw/SimpleWindowMac.cpp +++ b/source/MaterialXRenderHw/SimpleWindowMac.cpp @@ -5,6 +5,8 @@ #if defined(__APPLE__) +#ifndef TARGET_OS_IOS + #include #include @@ -42,3 +44,5 @@ SimpleWindow::~SimpleWindow() MATERIALX_NAMESPACE_END #endif + +#endif diff --git a/source/MaterialXRenderHw/WindowCocoaWrappers.m b/source/MaterialXRenderHw/WindowCocoaWrappers.m index c73de77810..a012966a8f 100644 --- a/source/MaterialXRenderHw/WindowCocoaWrappers.m +++ b/source/MaterialXRenderHw/WindowCocoaWrappers.m @@ -5,6 +5,8 @@ #if defined (__APPLE__) +#ifndef TARGET_OS_IOS + #import #import #import @@ -72,3 +74,5 @@ void NSUtilDisposeWindow(void* pWindow) } #endif + +#endif diff --git a/source/MaterialXRenderHw/WindowWrapper.cpp b/source/MaterialXRenderHw/WindowWrapper.cpp index 315960fb2b..654498d5cd 100644 --- a/source/MaterialXRenderHw/WindowWrapper.cpp +++ b/source/MaterialXRenderHw/WindowWrapper.cpp @@ -84,8 +84,12 @@ WindowWrapper::WindowWrapper(ExternalWindowHandle externalHandle, DisplayHandle display) { _externalHandle = externalHandle; +#ifndef TARGET_OS_IOS // Cache a pointer to the window. _internalHandle = NSUtilGetView(externalHandle); +#else + _internalHandle = nullptr; +#endif } WindowWrapper::~WindowWrapper() diff --git a/source/MaterialXRenderMsl/CMakeLists.txt b/source/MaterialXRenderMsl/CMakeLists.txt index 5ad50ea2cc..4d5e286463 100644 --- a/source/MaterialXRenderMsl/CMakeLists.txt +++ b/source/MaterialXRenderMsl/CMakeLists.txt @@ -1,3 +1,5 @@ +set(MATERIALX_MODULE_NAME MaterialXRenderMsl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.m*") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") @@ -9,8 +11,10 @@ if(POLICY CMP0072) endif() if(APPLE) +if(NOT MATERIALX_BUILD_IOS) find_library(COCOA_FRAMEWORK Cocoa) find_package(OpenGL REQUIRED) +endif() file(GLOB_RECURSE materialx_source_oc "${CMAKE_CURRENT_SOURCE_DIR}/*.m") message("Objective C files: " ${materialx_source_oc}) set_source_files_properties(${materialx_source_oc} PROPERTIES @@ -34,7 +38,7 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") add_compile_options(-Wno-deprecated-declarations) endif() -add_library(MaterialXRenderMsl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_RENDERMSL_EXPORTS) @@ -42,23 +46,28 @@ set(COMMON_LIBRARIES MaterialXRenderHw MaterialXGenMsl ${CMAKE_DL_LIBS}) + +if(APPLE AND NOT MATERIALX_BUILD_IOS) +set(COMMON_LIBRARIES + ${COMMON_LIBRARIES} + "-framework Cocoa") +endif() if(MSVC) target_link_libraries( - MaterialXRenderMsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} Opengl32) elseif(APPLE) target_link_libraries( - MaterialXRenderMsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} ${OPENGL_LIBRARIES} "-framework Foundation" - "-framework Cocoa" "-framework Metal") elseif(UNIX) target_link_libraries( - MaterialXRenderMsl + ${MATERIALX_MODULE_NAME} ${COMMON_LIBRARIES} ${OPENGL_LIBRARIES} ${X11_LIBRARIES} @@ -66,29 +75,31 @@ elseif(UNIX) endif() set_target_properties( - MaterialXRenderMsl PROPERTIES - OUTPUT_NAME MaterialXRenderMsl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" VERSION "${MATERIALX_LIBRARY_VERSION}" SOVERSION "${MATERIALX_MAJOR_VERSION}") -target_include_directories(MaterialXRenderMsl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXRenderMsl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXRenderMsl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXRenderMsl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXRenderMsl/MslMaterial.mm b/source/MaterialXRenderMsl/MslMaterial.mm index 7e9cd38adc..66fc0462f2 100644 --- a/source/MaterialXRenderMsl/MslMaterial.mm +++ b/source/MaterialXRenderMsl/MslMaterial.mm @@ -199,7 +199,7 @@ imageHandler->setFilenameResolver(resolver); // Acquire the given image. - return imageHandler->acquireImage(filePath); + return imageHandler->acquireImage(filePath, samplingProperties.defaultColor); } void MslMaterial::bindLighting(LightHandlerPtr lightHandler, diff --git a/source/MaterialXRenderMsl/MslPipelineStateObject.mm b/source/MaterialXRenderMsl/MslPipelineStateObject.mm index 84a615fd61..4f8378ae46 100644 --- a/source/MaterialXRenderMsl/MslPipelineStateObject.mm +++ b/source/MaterialXRenderMsl/MslPipelineStateObject.mm @@ -542,7 +542,7 @@ int GetStrideOfMetalType(MTLDataType type) { // Acquire the image. string error; - ImagePtr image = imageHandler->acquireImage(filePath); + ImagePtr image = imageHandler->acquireImage(filePath, samplingProperties.defaultColor); imageHandler->bindImage(image, samplingProperties); return bindTexture(renderCmdEncoder, uniformLocation, image, imageHandler); } diff --git a/source/MaterialXRenderMsl/MslRenderer.h b/source/MaterialXRenderMsl/MslRenderer.h index bf968078fe..1c54bdbc6a 100644 --- a/source/MaterialXRenderMsl/MslRenderer.h +++ b/source/MaterialXRenderMsl/MslRenderer.h @@ -126,9 +126,6 @@ class MX_RENDERMSL_API MslRenderer : public ShaderRenderer protected: MslRenderer(unsigned int width, unsigned int height, Image::BaseType baseType); - - virtual void updateViewInformation(); - virtual void updateWorldInformation(); void triggerProgrammaticCapture(); void stopProgrammaticCapture(); @@ -146,11 +143,6 @@ class MX_RENDERMSL_API MslRenderer : public ShaderRenderer bool _initialized; - const Vector3 _eye; - const Vector3 _center; - const Vector3 _up; - float _objectScale; - SimpleWindowPtr _window; Color3 _screenColor; }; diff --git a/source/MaterialXRenderMsl/MslRenderer.mm b/source/MaterialXRenderMsl/MslRenderer.mm index f6de188b2f..072f6f1a3a 100644 --- a/source/MaterialXRenderMsl/MslRenderer.mm +++ b/source/MaterialXRenderMsl/MslRenderer.mm @@ -14,13 +14,6 @@ MATERIALX_NAMESPACE_BEGIN -const float PI = std::acos(-1.0f); - -// View information -const float FOV_PERSP = 45.0f; // degrees -const float NEAR_PLANE_PERSP = 0.05f; -const float FAR_PLANE_PERSP = 100.0f; - // // MslRenderer methods // @@ -36,20 +29,14 @@ } MslRenderer::MslRenderer(unsigned int width, unsigned int height, Image::BaseType baseType) : - ShaderRenderer(width, height, baseType), + ShaderRenderer(width, height, baseType, MatrixConvention::Metal), _initialized(false), - _eye(0.0f, 0.0f, 3.0f), - _center(0.0f, 0.0f, 0.0f), - _up(0.0f, 1.0f, 0.0f), - _objectScale(1.0f), _screenColor(DEFAULT_SCREEN_COLOR_LIN_REC709) { _program = MslProgram::create(); _geometryHandler = GeometryHandler::create(); _geometryHandler->addLoader(TinyObjLoader::create()); - - _camera = Camera::create(); } void MslRenderer::initialize(RenderContextHandle) @@ -160,20 +147,6 @@ } -void MslRenderer::updateViewInformation() -{ - float fH = std::tan(FOV_PERSP / 360.0f * PI) * NEAR_PLANE_PERSP; - float fW = fH * 1.0f; - - _camera->setViewMatrix(Camera::createViewMatrix(_eye, _center, _up)); - _camera->setProjectionMatrix(Camera::createPerspectiveMatrixZP(-fW, fW, -fH, fH, NEAR_PLANE_PERSP, FAR_PLANE_PERSP)); -} - -void MslRenderer::updateWorldInformation() -{ - _camera->setWorldMatrix(Matrix44::createScale(Vector3(_objectScale))); -} - void MslRenderer::triggerProgrammaticCapture() { MTLCaptureManager* captureManager = [MTLCaptureManager sharedCaptureManager]; @@ -217,9 +190,6 @@ [renderCmdEncoder setCullMode:MTLCullModeBack]; - - updateViewInformation(); - updateWorldInformation(); try { diff --git a/source/MaterialXRenderOsl/CMakeLists.txt b/source/MaterialXRenderOsl/CMakeLists.txt index a4ffa81235..ac1de93d2e 100644 --- a/source/MaterialXRenderOsl/CMakeLists.txt +++ b/source/MaterialXRenderOsl/CMakeLists.txt @@ -1,16 +1,24 @@ +set(MATERIALX_MODULE_NAME MaterialXRenderOsl) + file(GLOB_RECURSE materialx_source "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") file(GLOB_RECURSE materialx_headers "${CMAKE_CURRENT_SOURCE_DIR}/*.h*") assign_source_group("Source Files" ${materialx_source}) assign_source_group("Header Files" ${materialx_headers}) -add_library(MaterialXRenderOsl ${materialx_source} ${materialx_headers}) +add_library(${MATERIALX_MODULE_NAME} ${materialx_source} ${materialx_headers}) add_definitions(-DMATERIALX_RENDEROSL_EXPORTS) +# Create version resource +if(MATERIALX_BUILD_SHARED_LIBS AND MSVC) + configure_file(${CMAKE_SOURCE_DIR}/cmake/modules/MaterialXVersion.rc.in ${CMAKE_CURRENT_BINARY_DIR}/version.rc) + target_sources(${MATERIALX_MODULE_NAME} PRIVATE ${CMAKE_CURRENT_BINARY_DIR}/version.rc) +endif() + set_target_properties( - MaterialXRenderOsl PROPERTIES - OUTPUT_NAME MaterialXRenderOsl${MATERIALX_LIBNAME_SUFFIX} + ${MATERIALX_MODULE_NAME} PROPERTIES + OUTPUT_NAME ${MATERIALX_MODULE_NAME}${MATERIALX_LIBNAME_SUFFIX} COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_SAME_DIR_RPATH}" @@ -18,26 +26,28 @@ set_target_properties( SOVERSION "${MATERIALX_MAJOR_VERSION}") target_link_libraries( - MaterialXRenderOsl + ${MATERIALX_MODULE_NAME} MaterialXRender ${CMAKE_DL_LIBS}) -target_include_directories(MaterialXRenderOsl +target_include_directories(${MATERIALX_MODULE_NAME} PUBLIC $ $ PRIVATE ${EXTERNAL_INCLUDE_DIRS}) -install(TARGETS MaterialXRenderOsl - EXPORT MaterialX - ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} - RUNTIME DESTINATION bin) +if(NOT SKBUILD) + install(TARGETS ${MATERIALX_MODULE_NAME} + EXPORT MaterialX + ARCHIVE DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + LIBRARY DESTINATION ${MATERIALX_INSTALL_LIB_PATH} + RUNTIME DESTINATION bin) -install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" - DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/MaterialXRenderOsl/ MESSAGE_NEVER - FILES_MATCHING PATTERN "*.h*") + install(DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/" + DESTINATION ${MATERIALX_INSTALL_INCLUDE_PATH}/${MATERIALX_MODULE_NAME}/ MESSAGE_NEVER + FILES_MATCHING PATTERN "*.h*") -install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/MaterialXRenderOsl.pdb" - DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/${MATERIALX_MODULE_NAME}.pdb" + DESTINATION "${MATERIALX_INSTALL_LIB_PATH}/" OPTIONAL) +endif() diff --git a/source/MaterialXTest/MaterialXRenderMsl/RenderMsl.mm b/source/MaterialXTest/MaterialXRenderMsl/RenderMsl.mm index f33e793690..248d458542 100644 --- a/source/MaterialXTest/MaterialXRenderMsl/RenderMsl.mm +++ b/source/MaterialXTest/MaterialXRenderMsl/RenderMsl.mm @@ -78,7 +78,7 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con void MslShaderRenderTester::loadAdditionalLibraries(mx::DocumentPtr document, GenShaderUtil::TestSuiteOptions& options) { - mx::FilePath lightDir = mx::FilePath::getCurrentPath() / mx::FilePath("resources/Materials/TestSuite/lights"); + mx::FilePath lightDir = mx::getDefaultDataSearchPath().find("resources/Materials/TestSuite/lights"); for (const auto& lightFile : options.lightFiles) { loadLibrary(lightDir / mx::FilePath(lightFile), document); @@ -135,6 +135,7 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con mx::StbImageLoaderPtr stbLoader = mx::StbImageLoader::create(); mx::ImageHandlerPtr imageHandler = _renderer->createImageHandler(stbLoader); + imageHandler->setSearchPath(mx::getDefaultDataSearchPath()); #if defined(MATERIALX_BUILD_OIIO) mx::OiioImageLoaderPtr oiioLoader = mx::OiioImageLoader::create(); imageHandler->addLoader(oiioLoader); @@ -179,6 +180,7 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con std::cout << "Validating MSL rendering for: " << doc->getSourceUri() << std::endl; mx::ScopedTimer totalMSLTime(&profileTimes.languageTimes.totalTime); + mx::FileSearchPath searchPath = mx::getDefaultDataSearchPath(); const mx::ShaderGenerator& shadergen = context.getShaderGenerator(); @@ -277,7 +279,7 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con { if (!testOptions.renderGeometry.isAbsolute()) { - geomPath = mx::FilePath::getCurrentPath() / mx::FilePath("resources/Geometry") / testOptions.renderGeometry; + geomPath = searchPath.find("resources/Geometry") / testOptions.renderGeometry; } else { @@ -286,7 +288,7 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con } else { - geomPath = mx::FilePath::getCurrentPath() / mx::FilePath("resources/Geometry/sphere.obj"); + geomPath = searchPath.find("resources/Geometry/sphere.obj"); } if (!geomHandler->hasGeometry(geomPath)) @@ -373,7 +375,7 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con { { mx::ScopedTimer renderTimer(&profileTimes.languageTimes.renderTime); - _renderer->getImageHandler()->setSearchPath(imageSearchPath); + _renderer->getImageHandler()->setSearchPath(mx::getDefaultDataSearchPath()); _renderer->setSize(static_cast(testOptions.renderSize[0]), static_cast(testOptions.renderSize[1])); _renderer->render(); } @@ -456,18 +458,10 @@ void runBake(mx::DocumentPtr doc, const mx::FileSearchPath& imageSearchPath, con TEST_CASE("Render: MSL TestSuite", "[rendermsl]") { - MslShaderRenderTester renderTester(mx::MslShaderGenerator::create()); - - const mx::FilePath testRootPath = mx::FilePath::getCurrentPath() / mx::FilePath("resources/Materials/TestSuite"); - const mx::FilePath testRootPath2 = mx::FilePath::getCurrentPath() / mx::FilePath("resources/Materials/Examples/StandardSurface"); - const mx::FilePath testRootPath3 = mx::FilePath::getCurrentPath() / mx::FilePath("resources/Materials/Examples/UsdPreviewSurface"); - mx::FilePathVec testRootPaths; - testRootPaths.push_back(testRootPath); - testRootPaths.push_back(testRootPath2); - testRootPaths.push_back(testRootPath3); - - mx::FilePath optionsFilePath = testRootPath / mx::FilePath("_options.mtlx"); + mx::FileSearchPath searchPath = mx::getDefaultDataSearchPath(); + mx::FilePath optionsFilePath = searchPath.find("resources/Materials/TestSuite/_options.mtlx"); + MslShaderRenderTester renderTester(mx::MslShaderGenerator::create()); renderTester.validate(optionsFilePath); } diff --git a/source/MaterialXView/Viewer.cpp b/source/MaterialXView/Viewer.cpp index ecbb4352fc..6346658d07 100644 --- a/source/MaterialXView/Viewer.cpp +++ b/source/MaterialXView/Viewer.cpp @@ -474,7 +474,7 @@ void Viewer::loadEnvironmentLight() } // Look for an irradiance map using an expected filename convention. - mx::ImagePtr envIrradianceMap = _imageHandler->getInvalidImage(); + mx::ImagePtr envIrradianceMap = _imageHandler->getZeroImage(); if (!_normalizeEnvironment && !_splitDirectLight) { mx::FilePath envIrradiancePath = _envRadianceFilename.getParentPath() / IRRADIANCE_MAP_FOLDER / _envRadianceFilename.getBaseName(); @@ -482,7 +482,7 @@ void Viewer::loadEnvironmentLight() } // If not found, then generate an irradiance map via spherical harmonics. - if (envIrradianceMap == _imageHandler->getInvalidImage()) + if (envIrradianceMap == _imageHandler->getZeroImage()) { if (_generateReferenceIrradiance) { diff --git a/source/PyMaterialX/PyMaterialXCore/CMakeLists.txt b/source/PyMaterialX/PyMaterialXCore/CMakeLists.txt index dfc2aefac0..9f3d2291c0 100644 --- a/source/PyMaterialX/PyMaterialXCore/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXCore/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -24,4 +22,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXCore - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXCore/PyNode.cpp b/source/PyMaterialX/PyMaterialXCore/PyNode.cpp index 704cda7589..55448dee80 100644 --- a/source/PyMaterialX/PyMaterialXCore/PyNode.cpp +++ b/source/PyMaterialX/PyMaterialXCore/PyNode.cpp @@ -59,6 +59,7 @@ void bindPyNode(py::module& mod) .def("addInterfaceName", &mx::NodeGraph::addInterfaceName) .def("removeInterfaceName", &mx::NodeGraph::removeInterfaceName) .def("modifyInterfaceName", &mx::NodeGraph::modifyInterfaceName) + .def("getDownstreamPorts", &mx::NodeGraph::getDownstreamPorts) .def_readonly_static("CATEGORY", &mx::NodeGraph::CATEGORY); py::class_(mod, "Backdrop") diff --git a/source/PyMaterialX/PyMaterialXFormat/CMakeLists.txt b/source/PyMaterialX/PyMaterialXFormat/CMakeLists.txt index 9566e792fd..095b3eb087 100644 --- a/source/PyMaterialX/PyMaterialXFormat/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXFormat/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -25,4 +23,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXFormat - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXGenGlsl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXGenGlsl/CMakeLists.txt index b65ef857a4..24266712fd 100644 --- a/source/PyMaterialX/PyMaterialXGenGlsl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXGenGlsl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -25,4 +23,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXGenGlsl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXGenMdl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXGenMdl/CMakeLists.txt index a1bc225a4f..328a2439ed 100644 --- a/source/PyMaterialX/PyMaterialXGenMdl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXGenMdl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -24,4 +22,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXGenMdl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXGenMsl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXGenMsl/CMakeLists.txt index 88e21687bc..33dec7319a 100644 --- a/source/PyMaterialX/PyMaterialXGenMsl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXGenMsl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -25,4 +23,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXGenMsl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXGenOsl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXGenOsl/CMakeLists.txt index 5d30769b4d..65b0dabe67 100644 --- a/source/PyMaterialX/PyMaterialXGenOsl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXGenOsl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -25,4 +23,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXGenOsl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXGenShader/CMakeLists.txt b/source/PyMaterialX/PyMaterialXGenShader/CMakeLists.txt index 13c01b3351..5bee142c24 100644 --- a/source/PyMaterialX/PyMaterialXGenShader/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXGenShader/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -26,4 +24,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXGenShader - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXRender/CMakeLists.txt b/source/PyMaterialX/PyMaterialXRender/CMakeLists.txt index a050cb6aa3..2617a0b392 100644 --- a/source/PyMaterialX/PyMaterialXRender/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXRender/CMakeLists.txt @@ -17,8 +17,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -28,4 +26,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXRender - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXRender/PyImageHandler.cpp b/source/PyMaterialX/PyMaterialXRender/PyImageHandler.cpp index 7ece49d60b..d261bc7306 100644 --- a/source/PyMaterialX/PyMaterialXRender/PyImageHandler.cpp +++ b/source/PyMaterialX/PyMaterialXRender/PyImageHandler.cpp @@ -41,7 +41,8 @@ void bindPyImageHandler(py::module& mod) .def("addLoader", &mx::ImageHandler::addLoader) .def("saveImage", &mx::ImageHandler::saveImage, py::arg("filePath"), py::arg("image"), py::arg("verticalFlip") = false) - .def("acquireImage", &mx::ImageHandler::acquireImage) + .def("acquireImage", &mx::ImageHandler::acquireImage, + py::arg("filePath"), py::arg("defaultColor") = mx::Color4(0.0f)) .def("bindImage", &mx::ImageHandler::bindImage) .def("unbindImage", &mx::ImageHandler::unbindImage) .def("unbindImages", &mx::ImageHandler::unbindImages) @@ -54,6 +55,5 @@ void bindPyImageHandler(py::module& mod) py::arg("image") = nullptr) .def("clearImageCache", &mx::ImageHandler::clearImageCache) .def("getZeroImage", &mx::ImageHandler::getZeroImage) - .def("getInvalidImage", &mx::ImageHandler::getInvalidImage) .def("getReferencedImages", &mx::ImageHandler::getReferencedImages); } diff --git a/source/PyMaterialX/PyMaterialXRenderGlsl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXRenderGlsl/CMakeLists.txt index a29cdc5c1e..a0b04ddbda 100644 --- a/source/PyMaterialX/PyMaterialXRenderGlsl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXRenderGlsl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -27,4 +25,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXRenderGlsl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXRenderMsl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXRenderMsl/CMakeLists.txt index ec562fe8cf..04c6d95e3c 100644 --- a/source/PyMaterialX/PyMaterialXRenderMsl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXRenderMsl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -27,4 +25,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXRenderMsl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}") diff --git a/source/PyMaterialX/PyMaterialXRenderOsl/CMakeLists.txt b/source/PyMaterialX/PyMaterialXRenderOsl/CMakeLists.txt index 4777b13e7b..c0b83948a9 100644 --- a/source/PyMaterialX/PyMaterialXRenderOsl/CMakeLists.txt +++ b/source/PyMaterialX/PyMaterialXRenderOsl/CMakeLists.txt @@ -14,8 +14,6 @@ set_target_properties( COMPILE_FLAGS "${EXTERNAL_COMPILE_FLAGS}" LINK_FLAGS "${EXTERNAL_LINK_FLAGS}" INSTALL_RPATH "${MATERIALX_UP_TWO_RPATH}" - VERSION "${MATERIALX_LIBRARY_VERSION}" - SOVERSION "${MATERIALX_MAJOR_VERSION}" DEBUG_POSTFIX "${MATERIALX_PYTHON_DEBUG_POSTFIX}") target_link_libraries( @@ -25,4 +23,4 @@ target_link_libraries( PRIVATE ${CMAKE_DL_LIBS}) install(TARGETS PyMaterialXRenderOsl - DESTINATION "python/MaterialX") + DESTINATION "${MATERIALX_PYTHON_FOLDER_NAME}")