CMakeLists.txt

@@ -794,7 +794,7 @@ set(POSTCONFIGURE_SCRIPT "" CACHE FILEPATH "Run given CMake script as the last s
 mark_as_advanced(POSTCONFIGURE_SCRIPT)
 
 # USD Hydra plugin.
-if(WIN32 AND WITH_USD)
+if(WIN32 AND WITH_USD AND WITH_MATERIALX)
   option(WITH_HYDRA "Enable USD Hydra plugin" ON)
 endif()
 

build_files/cmake/platform/platform_win32.cmake

@@ -899,6 +899,13 @@ if(WITH_USD)
   endif()
 endif()
 
+if(WITH_MATERIALX)
+  windows_find_package(MaterialX)
+  if(NOT MaterialX_FOUND)
+    include("${LIBDIR}/MaterialX/lib/cmake/MaterialX/MaterialXTargets.cmake")
+  endif()
+endif()
+
 if(WINDOWS_PYTHON_DEBUG)
   # Include the system scripts in the blender_python_system_scripts project.
   file(GLOB_RECURSE inFiles "${CMAKE_SOURCE_DIR}/release/scripts/*.*" )

source/blender/render/hydra/CMakeLists.txt

@@ -1,6 +1,10 @@
 # SPDX-License-Identifier: Apache-2.0
 # Copyright 2011-2022 Blender Foundation
 
+if(NOT TARGET MaterialXCore OR NOT TARGET MaterialXFormat)
+  message(FATAL_ERROR "Hydra Scene Delegate requires MaterialX")
+endif()
+
 if(WIN32)
   add_definitions(-DNOMINMAX -DWIN32_LEAN_AND_MEAN -DBOOST_DEBUG_PYTHON)
 endif()
@@ -50,6 +54,8 @@ set(SRC
   engine.cc
   finalEngine.h
   finalEngine.cc
+  previewEngine.h
+  previewEngine.cc
   viewportEngine.h
   viewportEngine.cc
   camera.h
@@ -72,6 +78,8 @@ set(SRC
   sceneDelegate/material.cc
   sceneDelegate/mesh.h
   sceneDelegate/mesh.cc
+  sceneDelegate/mtlxHydraAdapter.h
+  sceneDelegate/mtlxHydraAdapter.cc
   sceneDelegate/light.h
   sceneDelegate/light.cc
   sceneDelegate/world.h
@@ -86,4 +94,8 @@ set(LIB
 
 blender_add_lib(bf_render_hydra "${SRC}" "${INC}" "${INC_SYS}" "${LIB}")
 
+target_link_libraries(bf_render_hydra PRIVATE
+    MaterialXCore
+    MaterialXFormat)
+
 add_dependencies(bf_render_hydra bf_rna)

source/blender/render/hydra/engine.h

@@ -28,6 +28,7 @@ public:
   virtual ~Engine();
 
   virtual void sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings) = 0;
+  virtual void render(BL::Depsgraph &b_depsgraph) = 0;
 
 protected:
   float getRendererPercentDone();

source/blender/render/hydra/finalEngine.cc

@@ -19,10 +19,10 @@ using namespace pxr;
 
 namespace blender::render::hydra {
 
-void FinalEngine::sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings)
+void FinalEngine::sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, HdRenderSettingsMap &renderSettings)
 {
   sceneDelegate = std::make_unique<BlenderSceneDelegate>(renderIndex.get(), 
-    SdfPath::AbsoluteRootPath().AppendElementString("scene"));
+    SdfPath::AbsoluteRootPath().AppendElementString("scene"), BlenderSceneDelegate::EngineType::Final);
   sceneDelegate->populate((Depsgraph *)b_depsgraph.ptr.data, (bContext *)b_context.ptr.data);
 
   for (auto const& setting : renderSettings) {

source/blender/render/hydra/finalEngine.h

@@ -12,8 +12,8 @@ namespace blender::render::hydra {
 class FinalEngine : public Engine {
 public:
   using Engine::Engine;
-  void sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings) override;
+  virtual void sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings) override;
-  virtual void render(BL::Depsgraph &b_depsgraph);
+  virtual void render(BL::Depsgraph &b_depsgraph) override;
 
 protected:
   pxr::GfVec2i get_resolution(BL::RenderSettings b_render);

source/blender/render/hydra/previewEngine.cc

@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: Apache-2.0
+* Copyright 2011-2022 Blender Foundation */
+
+#include <pxr/usdImaging/usdAppUtils/camera.h>
+
+#include "previewEngine.h"
+#include "camera.h"
+
+using namespace pxr;
+using namespace std;
+
+namespace blender::render::hydra {
+
+void PreviewEngine::sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, HdRenderSettingsMap &renderSettings)
+{
+  sceneDelegate = std::make_unique<BlenderSceneDelegate>(renderIndex.get(), 
+    SdfPath::AbsoluteRootPath().AppendElementString("scene"), BlenderSceneDelegate::EngineType::Preview);
+  sceneDelegate->populate((Depsgraph *)b_depsgraph.ptr.data, (bContext *)b_context.ptr.data);
+
+  for (auto const& setting : renderSettings) {
+    renderDelegate->SetRenderSetting(setting.first, setting.second);
+  }
+}
+
+void PreviewEngine::render(BL::Depsgraph &b_depsgraph)
+{
+  BL::Scene b_scene = b_depsgraph.scene();
+  string layerName = b_depsgraph.view_layer().name();
+  GfVec2i buffer_res {b_scene.render().resolution_x(),
+                      b_scene.render().resolution_y()};
+
+  GfCamera gfCamera = CameraData((Object *)b_scene.camera().ptr.data, buffer_res, GfVec4f(0, 0, 1, 1)).gf_camera(GfVec4f(0, 0, 1, 1));
+
+  freeCameraDelegate->SetCamera(gfCamera);
+  renderTaskDelegate->SetCameraAndViewport(freeCameraDelegate->GetCameraId(), GfVec4d(0, 0, buffer_res[0], buffer_res[1]));
+  renderTaskDelegate->SetRendererAov(HdAovTokens->color);
+
+  HdTaskSharedPtrVector tasks;
+  if (simpleLightTaskDelegate) {
+    tasks.push_back(simpleLightTaskDelegate->GetTask());
+  }
+  tasks.push_back(renderTaskDelegate->GetTask());
+
+  vector<float> pixels = vector<float>(buffer_res[0] * buffer_res[1] * 4);  // 4 - number of channels
+
+  {
+    // Release the GIL before calling into hydra, in case any hydra plugins call into python.
+    TF_PY_ALLOW_THREADS_IN_SCOPE();
+    engine->Execute(renderIndex.get(), &tasks);
+  }
+
+  while (true) {
+    if (b_engine.test_break()) {
+      break;
+    }
+
+    if (renderTaskDelegate->IsConverged()) {
+      break;
+    }
+
+    renderTaskDelegate->GetRendererAovData(HdAovTokens->color, pixels.data());
+    updateRenderResult(layerName, buffer_res[0], buffer_res[1], pixels);
+  }
+
+  renderTaskDelegate->GetRendererAovData(HdAovTokens->color, pixels.data());
+  updateRenderResult(layerName, buffer_res[0], buffer_res[1], pixels);
+}
+
+void PreviewEngine::updateRenderResult(const string &layerName, int width, int height, vector<float> &pixels)
+{
+  BL::RenderResult b_result = b_engine.begin_result(0, 0, width, height, layerName.c_str(), NULL);
+  BL::CollectionRef b_passes = b_result.layers[0].passes;
+  b_passes[0].rect(pixels.data());
+  b_engine.end_result(b_result, false, false, false);
+}
+
+}   // namespace blender::render::hydra

source/blender/render/hydra/previewEngine.h

@@ -0,0 +1,23 @@
+/* SPDX-License-Identifier: Apache-2.0
+* Copyright 2011-2022 Blender Foundation */
+
+#pragma once
+
+#include "finalEngine.h"
+
+namespace blender::render::hydra {
+
+  class PreviewEngine : public FinalEngine {
+  public:
+    using FinalEngine::FinalEngine;
+    void sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings) override;
+    void render(BL::Depsgraph &b_depsgraph) override;
+
+  protected:
+    void updateRenderResult(const std::string &layerName, int width, int height, std::vector<float> &pixels);
+
+  protected:
+    HdRenderSettingsMap renderSettings;
+  };
+
+}   // namespace blender::render::hydra

source/blender/render/hydra/python.cc

@@ -16,6 +16,7 @@
 
 #include "finalEngine.h"
 #include "viewportEngine.h"
+#include "previewEngine.h"
 
 using namespace std;
 
@@ -130,9 +131,13 @@ static PyObject *engine_create_func(PyObject * /*self*/, PyObject *args)
   BL::RenderEngine b_engine(engineptr);
 
   Engine *engine;
+
   if (string(engineType) == "VIEWPORT") {
     engine = new ViewportEngine(b_engine, delegateId);
   }
+  else if (string(engineType) == "PREVIEW") {
+    engine = new PreviewEngine(b_engine, delegateId);
+  }
   else {
     if (b_engine.bl_use_gpu_context()) {
       engine = new FinalEngineGL(b_engine, delegateId);
@@ -204,11 +209,12 @@ static PyObject *engine_sync_func(PyObject * /*self*/, PyObject *args)
 static PyObject *engine_render_func(PyObject * /*self*/, PyObject *args)
 {
   PyObject *pyengine, *pydepsgraph;
+
   if (!PyArg_ParseTuple(args, "OO", &pyengine, &pydepsgraph)) {
     Py_RETURN_NONE;
   }
 
-  FinalEngine *engine = (FinalEngine *)PyLong_AsVoidPtr(pyengine);
+  Engine *engine = (Engine *)PyLong_AsVoidPtr(pyengine);
 
   PointerRNA depsgraphptr;
   RNA_pointer_create(NULL, &RNA_Depsgraph, (ID *)PyLong_AsVoidPtr(pydepsgraph), &depsgraphptr);
@@ -241,7 +247,7 @@ static PyObject *engine_view_draw_func(PyObject * /*self*/, PyObject *args)
 
   /* Allow Blender to execute other Python scripts. */
   Py_BEGIN_ALLOW_THREADS
-    engine->viewDraw(b_depsgraph, b_context);
+    engine->render(b_depsgraph, b_context);
   Py_END_ALLOW_THREADS
 
   Py_RETURN_NONE;

source/blender/render/hydra/sceneDelegate/blenderSceneDelegate.cc

@@ -12,8 +12,9 @@ using namespace pxr;
 
 namespace blender::render::hydra {
 
-BlenderSceneDelegate::BlenderSceneDelegate(HdRenderIndex* parentIndex, SdfPath const& delegateID)
+BlenderSceneDelegate::BlenderSceneDelegate(HdRenderIndex* parentIndex, SdfPath const& delegateID, BlenderSceneDelegate::EngineType engine_type)
   : HdSceneDelegate(parentIndex, delegateID)
+  , engine_type(engine_type)
   , depsgraph(nullptr)
   , context(nullptr)
   , view3d(nullptr)

source/blender/render/hydra/sceneDelegate/blenderSceneDelegate.h

@@ -17,7 +17,13 @@ namespace blender::render::hydra {
 
 class BlenderSceneDelegate : public pxr::HdSceneDelegate {
 public:
-  BlenderSceneDelegate(pxr::HdRenderIndex *renderIndex, pxr::SdfPath const &delegateId);
+  enum class EngineType {
+    Viewport = 1,
+    Final,
+    Preview
+  };
+
+  BlenderSceneDelegate(pxr::HdRenderIndex *renderIndex, pxr::SdfPath const &delegateId, BlenderSceneDelegate::EngineType engine_type);
   ~BlenderSceneDelegate() override = default;
 
   void populate(Depsgraph *depsgraph, bContext *context);
@@ -40,6 +46,8 @@ public:
   size_t SamplePrimvar(pxr::SdfPath const &id, pxr::TfToken const &key, size_t maxSampleCount,
                        float *sampleTimes, pxr::VtValue *sampleValues) override;
 
+  EngineType engine_type;
+
  private:
   ObjectData *object_data(pxr::SdfPath const &id);
   MeshData *mesh_data(pxr::SdfPath const &id);

source/blender/render/hydra/sceneDelegate/id.cc

@@ -3,13 +3,14 @@
 
 #include "BKE_lib_id.h"
 
+#include "blenderSceneDelegate.h"
 #include "id.h"
 
 using namespace pxr;
 
 namespace blender::render::hydra {
 
-IdData::IdData(pxr::HdSceneDelegate *scene_delegate, ID *id)
+IdData::IdData(BlenderSceneDelegate *scene_delegate, ID *id)
   : scene_delegate(scene_delegate)
   , id(id)
 {

source/blender/render/hydra/sceneDelegate/id.h

@@ -11,9 +11,11 @@
 
 namespace blender::render::hydra {
 
+class BlenderSceneDelegate;
+
 class IdData {
  public:
-  IdData(pxr::HdSceneDelegate *scene_delegate, ID *id);
+  IdData(BlenderSceneDelegate *scene_delegate, ID *id);
   virtual ~IdData() = default;
 
   std::string name();
@@ -32,7 +34,7 @@ class IdData {
   virtual void mark_prim_dirty(DirtyBits dirty_bits) = 0;
 
  protected:
-  pxr::HdSceneDelegate *scene_delegate;
+  BlenderSceneDelegate *scene_delegate;
   ID *id;
 };
 

source/blender/render/hydra/sceneDelegate/light.cc

@@ -12,6 +12,7 @@
 #include "BKE_light.h"
 #include "DNA_light_types.h"
 
+#include "blenderSceneDelegate.h"
 #include "light.h"
 
 using namespace pxr;
@@ -19,12 +20,15 @@ using namespace boost::algorithm;
 
 namespace blender::render::hydra {
 
-LightData::LightData(pxr::HdSceneDelegate *scene_delegate, Object *object)
+LightData::LightData(BlenderSceneDelegate *scene_delegate, Object *object)
   : ObjectData(scene_delegate, object)
 {
   Light *light = (Light *)((Object *)id)->data;
 
-  data[HdLightTokens->intensity] = light->energy;
+  data[HdLightTokens->intensity] = scene_delegate->engine_type == BlenderSceneDelegate::EngineType::Preview
+    ? light->energy / 1000
+    : light->energy;
+
   data[HdLightTokens->color] = GfVec3f(light->r, light->g, light->b);
 
   switch (light->type) {

source/blender/render/hydra/sceneDelegate/light.h

@@ -13,7 +13,7 @@ namespace blender::render::hydra {
 
 class LightData: public ObjectData {
  public:
-  LightData(pxr::HdSceneDelegate *scene_delegate, Object *object);
+  LightData(BlenderSceneDelegate *scene_delegate, Object *object);
 
   pxr::VtValue get_data(pxr::TfToken const &key) override;
   void insert_prim() override;

source/blender/render/hydra/sceneDelegate/material.cc

@@ -5,24 +5,27 @@
 
 #include <pxr/imaging/hd/tokens.h>
 #include <pxr/imaging/hd/material.h>
+#include <pxr/imaging/hd/renderDelegate.h>
 
 #include "glog/logging.h"
 
 #include "BKE_material.h"
 #include "BKE_lib_id.h"
 
+#include "blenderSceneDelegate.h"
 #include "material.h"
+#include "mtlxHydraAdapter.h"
 
 using namespace pxr;
 
 namespace blender::render::hydra {
 
-std::unique_ptr<MaterialData> MaterialData::init(pxr::HdSceneDelegate *scene_delegate, Material *material)
+std::unique_ptr<MaterialData> MaterialData::init(BlenderSceneDelegate *scene_delegate, Material *material)
 {
   return std::make_unique<MaterialData>(scene_delegate, material);
 }
 
-pxr::SdfPath MaterialData::prim_id(pxr::HdSceneDelegate *scene_delegate, Material *material)
+pxr::SdfPath MaterialData::prim_id(BlenderSceneDelegate *scene_delegate, Material *material)
 {
   /* Making id of material in form like M_<pointer in 16 hex digits format>.
    * Example: M_000002074e812088 */
@@ -32,7 +35,7 @@ pxr::SdfPath MaterialData::prim_id(pxr::HdSceneDelegate *scene_delegate, Materia
   return scene_delegate->GetDelegateID().AppendElementString(((ID *)material)->name);
 }
 
-MaterialData::MaterialData(pxr::HdSceneDelegate *scene_delegate, Material *material)
+MaterialData::MaterialData(BlenderSceneDelegate *scene_delegate, Material *material)
   : IdData(scene_delegate, (ID *)material)
 {
 }
@@ -50,7 +53,18 @@ VtValue MaterialData::get_data(TfToken const &key)
 
 pxr::VtValue MaterialData::material_resource()
 {
-  /* TODO: Implement return of HdMaterialNetwork */
+  std::string const &path = mtlx_path.GetResolvedPath();
+  if (!path.empty()) {
+    HdRenderDelegate *render_delegate = scene_delegate->GetRenderIndex().GetRenderDelegate();
+    TfTokenVector shader_source_types = render_delegate->GetShaderSourceTypes();
+    TfTokenVector render_contexts = render_delegate->GetMaterialRenderContexts();
+
+    HdMaterialNetworkMap material_network_map;
+    HdMtlxConvertToMaterialNetworkMap(
+        path, shader_source_types, render_contexts, &material_network_map);
+    return VtValue(material_network_map);
+  }
+
   return pxr::VtValue();
 }
 

source/blender/render/hydra/sceneDelegate/material.h

@@ -15,10 +15,10 @@ namespace blender::render::hydra {
 
 class MaterialData: IdData {
  public:
-  static std::unique_ptr<MaterialData> init(pxr::HdSceneDelegate *scene_delegate, Material *material);
+  static std::unique_ptr<MaterialData> init(BlenderSceneDelegate *scene_delegate, Material *material);
-  static pxr::SdfPath prim_id(pxr::HdSceneDelegate *scene_delegate, Material *material);
+  static pxr::SdfPath prim_id(BlenderSceneDelegate *scene_delegate, Material *material);
 
-  MaterialData(pxr::HdSceneDelegate *scene_delegate, Material *material);
+  MaterialData(BlenderSceneDelegate *scene_delegate, Material *material);
 
   pxr::VtValue get_data(pxr::TfToken const &key) override;
   void insert_prim() override;

source/blender/render/hydra/sceneDelegate/mesh.cc

@@ -11,6 +11,7 @@
 #include "BKE_object.h"
 #include "BKE_material.h"
 
+#include "blenderSceneDelegate.h"
 #include "mesh.h"
 #include "../utils.h"
 
@@ -18,7 +19,7 @@ using namespace pxr;
 
 namespace blender::render::hydra {
 
-MeshData::MeshData(pxr::HdSceneDelegate *scene_delegate, Object *object)
+MeshData::MeshData(BlenderSceneDelegate *scene_delegate, Object *object)
   : ObjectData(scene_delegate, object)
 {
   if (object->type == OB_MESH && object->mode == OB_MODE_OBJECT &&

source/blender/render/hydra/sceneDelegate/mesh.h

@@ -14,7 +14,7 @@ namespace blender::render::hydra {
 
 class MeshData: public ObjectData {
 public:
-  MeshData(pxr::HdSceneDelegate *scene_delegate, Object *object);
+  MeshData(BlenderSceneDelegate *scene_delegate, Object *object);
 
   pxr::VtValue get_data(pxr::TfToken const &key) override;
 

source/blender/render/hydra/sceneDelegate/mtlxHydraAdapter.cc

@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2011-2022 Blender Foundation */
+
+#include "mtlxHydraAdapter.h"
+
+#include <pxr/base/arch/fileSystem.h>
+
+#include <pxr/usd/ar/resolver.h>
+#include <pxr/usd/ar/resolverContextBinder.h>
+#include <pxr/usd/ar/resolverScopedCache.h>
+
+#include <pxr/usd/usdMtlx/reader.h>
+#include <pxr/usd/usdMtlx/utils.h>
+
+#include <pxr/usd/usdShade/material.h>
+#include <pxr/usd/usdShade/shader.h>
+
+#include <pxr/usdImaging/usdImaging/materialParamUtils.h>
+
+#include <pxr/imaging/hd/material.h>
+#include <pxr/imaging/hd/tokens.h>
+
+namespace mx = MaterialX;
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+void HdMtlxConvertToMaterialNetworkMap(std::string const &mtlxPath,
+                                       TfTokenVector const &shaderSourceTypes,
+                                       TfTokenVector const &renderContexts,
+                                       HdMaterialNetworkMap *out)
+{
+  if (mtlxPath.empty()) {
+    return;
+  }
+
+  std::string basePath = TfGetPathName(mtlxPath);
+
+  ArResolver &resolver = ArGetResolver();
+  const ArResolverContext context = resolver.CreateDefaultContextForAsset(mtlxPath);
+  ArResolverContextBinder binder(context);
+  ArResolverScopedCache resolverCache;
+
+  std::string mtlxName = TfGetBaseName(mtlxPath);
+  std::string stageId = TfStringPrintf(
+      "%s%s%s.usda", basePath.c_str(), ARCH_PATH_SEP, mtlxName.c_str());
+  UsdStageRefPtr stage = UsdStage::CreateInMemory(stageId, context);
+
+  try {
+    mx::DocumentPtr doc = UsdMtlxReadDocument(mtlxPath);
+    UsdMtlxRead(doc, stage);
+  }
+  catch (mx::ExceptionFoundCycle &x) {
+    TF_RUNTIME_ERROR("MaterialX cycle found: %s\n", x.what());
+    return;
+  }
+  catch (mx::Exception &x) {
+    TF_RUNTIME_ERROR("MaterialX error: %s\n", x.what());
+    return;
+  }
+  
+  if (UsdPrim materials = stage->GetPrimAtPath(SdfPath("/MaterialX/Materials"))) {
+    if (UsdPrimSiblingRange children = materials.GetChildren()) {
+      if (auto material = UsdShadeMaterial(*children.begin())) {
+        if (UsdShadeShader mtlxSurface = material.ComputeSurfaceSource(renderContexts)) {
+          UsdImagingBuildHdMaterialNetworkFromTerminal(mtlxSurface.GetPrim(),
+                                                       HdMaterialTerminalTokens->surface,
+                                                       shaderSourceTypes,
+                                                       renderContexts,
+                                                       out,
+                                                       UsdTimeCode::Default());
+        }
+      }
+    }
+  }
+}
+
+PXR_NAMESPACE_CLOSE_SCOPE

source/blender/render/hydra/sceneDelegate/mtlxHydraAdapter.h

@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: Apache-2.0
+ * Copyright 2011-2022 Blender Foundation */
+
+#pragma once
+
+#include <pxr/base/tf/token.h>
+#include <pxr/pxr.h>
+
+#include <string>
+
+PXR_NAMESPACE_OPEN_SCOPE
+
+struct HdMaterialNetworkMap;
+
+void HdMtlxConvertToMaterialNetworkMap(std::string const &mtlxPath,
+                                       TfTokenVector const &shaderSourceTypes,
+                                       TfTokenVector const &renderContexts,
+                                       HdMaterialNetworkMap *out);
+
+PXR_NAMESPACE_CLOSE_SCOPE

source/blender/render/hydra/sceneDelegate/object.cc

@@ -3,6 +3,7 @@
 
 #include "BKE_object.h"
 
+#include "blenderSceneDelegate.h"
 #include "object.h"
 #include "mesh.h"
 #include "light.h"
@@ -30,7 +31,7 @@ bool ObjectData::supported(Object *object)
   return false;
 }
 
-std::unique_ptr<ObjectData> ObjectData::init(pxr::HdSceneDelegate *scene_delegate, Object *object)
+std::unique_ptr<ObjectData> ObjectData::init(BlenderSceneDelegate *scene_delegate, Object *object)
 {
   switch (object->type) {
     case OB_MESH:
@@ -50,7 +51,7 @@ std::unique_ptr<ObjectData> ObjectData::init(pxr::HdSceneDelegate *scene_delegat
   return nullptr;
 }
 
-pxr::SdfPath ObjectData::prim_id(pxr::HdSceneDelegate *scene_delegate, Object *object)
+pxr::SdfPath ObjectData::prim_id(BlenderSceneDelegate *scene_delegate, Object *object)
 {
   /* Making id of object in form like O_<pointer in 16 hex digits format>. Example:
    * O_000002073e369608 */
@@ -60,7 +61,7 @@ pxr::SdfPath ObjectData::prim_id(pxr::HdSceneDelegate *scene_delegate, Object *o
   return scene_delegate->GetDelegateID().AppendElementString(((ID *)object)->name);
 }
 
-ObjectData::ObjectData(pxr::HdSceneDelegate *scene_delegate, Object *object)
+ObjectData::ObjectData(BlenderSceneDelegate *scene_delegate, Object *object)
   : IdData(scene_delegate, (ID *)object)
   , visible(true)
 {

source/blender/render/hydra/sceneDelegate/object.h

@@ -17,10 +17,10 @@ namespace blender::render::hydra {
 class ObjectData: public IdData {
 public:
   static bool supported(Object *object);
-  static std::unique_ptr<ObjectData> init(pxr::HdSceneDelegate *scene_delegate, Object *object);
+  static std::unique_ptr<ObjectData> init(BlenderSceneDelegate *scene_delegate, Object *object);
-  static pxr::SdfPath prim_id(pxr::HdSceneDelegate *scene_delegate, Object *object);
+  static pxr::SdfPath prim_id(BlenderSceneDelegate *scene_delegate, Object *object);
 
-  ObjectData(pxr::HdSceneDelegate *scene_delegate, Object *object);
+  ObjectData(BlenderSceneDelegate *scene_delegate, Object *object);
 
   int type();
   pxr::GfMatrix4d transform();

source/blender/render/hydra/sceneDelegate/world.cc

@@ -22,6 +22,7 @@
 
 #include "glog/logging.h"
 
+#include "blenderSceneDelegate.h"
 #include "world.h"
 #include "../utils.h"
 
@@ -31,18 +32,18 @@ using namespace pxr;
 
 namespace blender::render::hydra {
 
-std::unique_ptr<WorldData> WorldData::init(pxr::HdSceneDelegate *scene_delegate,
+std::unique_ptr<WorldData> WorldData::init(BlenderSceneDelegate *scene_delegate,
                                            World *world, bContext *context)
 {
   return std::make_unique<WorldData>(scene_delegate, world, context);
 }
 
-SdfPath WorldData::prim_id(HdSceneDelegate *scene_delegate)
+SdfPath WorldData::prim_id(BlenderSceneDelegate *scene_delegate)
 {
   return scene_delegate->GetDelegateID().AppendElementString("World");
 }
 
-WorldData::WorldData(pxr::HdSceneDelegate *scene_delegate, World *world, bContext *context)
+WorldData::WorldData(BlenderSceneDelegate *scene_delegate, World *world, bContext *context)
   : IdData(scene_delegate, (ID *)world)
 {
   data[UsdLuxTokens->orientToStageUpAxis] = true;

source/blender/render/hydra/sceneDelegate/world.h

@@ -20,10 +20,10 @@ namespace blender::render::hydra {
 
 class WorldData: public IdData {
 public:
-  static std::unique_ptr<WorldData> init(pxr::HdSceneDelegate *scene_delegate, World *world, bContext *context);
+  static std::unique_ptr<WorldData> init(BlenderSceneDelegate *scene_delegate, World *world, bContext *context);
-  static pxr::SdfPath prim_id(pxr::HdSceneDelegate *scene_delegate);
+  static pxr::SdfPath prim_id(BlenderSceneDelegate *scene_delegate);
 
-  WorldData(pxr::HdSceneDelegate *scene_delegate, World *world, bContext *context);
+  WorldData(BlenderSceneDelegate *scene_delegate, World *world, bContext *context);
 
   pxr::GfMatrix4d transform();
 

source/blender/render/hydra/viewportEngine.cc

@@ -244,7 +244,7 @@ void ViewportEngine::sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, Hd
 {
   if (!sceneDelegate) {
     sceneDelegate = std::make_unique<BlenderSceneDelegate>(renderIndex.get(), 
-      SdfPath::AbsoluteRootPath().AppendElementString("scene"));
+      SdfPath::AbsoluteRootPath().AppendElementString("scene"), BlenderSceneDelegate::EngineType::Viewport);
   }
   sceneDelegate->populate((Depsgraph *)b_depsgraph.ptr.data, (bContext *)b_context.ptr.data);
 
@@ -253,7 +253,7 @@ void ViewportEngine::sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, Hd
   }
 }
 
-void ViewportEngine::viewDraw(BL::Depsgraph &b_depsgraph, BL::Context &b_context)
+void ViewportEngine::render(BL::Depsgraph &b_depsgraph, BL::Context &b_context)
 {
   ViewSettings viewSettings(b_context);
   if (viewSettings.width() * viewSettings.height() == 0) {
@@ -314,6 +314,10 @@ void ViewportEngine::viewDraw(BL::Depsgraph &b_depsgraph, BL::Context &b_context
   }
 }
 
+void ViewportEngine::render(BL::Depsgraph &b_depsgraph)
+{
+}
+
 void ViewportEngine::notifyStatus(const string &info, const string &status)
 {
   b_engine.update_stats(status.c_str(), info.c_str());

source/blender/render/hydra/viewportEngine.h

@@ -33,7 +33,8 @@ class ViewportEngine : public Engine {
 public:
   using Engine::Engine;
   void sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings) override;
-  void viewDraw(BL::Depsgraph &b_depsgraph, BL::Context &b_context);
+  void render(BL::Depsgraph &b_depsgraph) override;
+  void render(BL::Depsgraph &b_depsgraph, BL::Context &b_context);
 
 private:
   void notifyStatus(const std::string &title, const std::string &info);

source/creator/CMakeLists.txt

@@ -980,6 +980,9 @@ elseif(WIN32)
       ${LIBDIR}/materialx/bin/MaterialXGenMdl.dll
       ${LIBDIR}/materialx/bin/MaterialXGenOsl.dll
       ${LIBDIR}/materialx/bin/MaterialXGenShader.dll
+      ${LIBDIR}/materialx/bin/MaterialXRender.dll
+      ${LIBDIR}/materialx/bin/MaterialXRenderHw.dll
+      ${LIBDIR}/materialx/bin/MaterialXRenderGlsl.dll
     RELEASE
   )
   windows_install_shared_manifest(
@@ -990,6 +993,9 @@ elseif(WIN32)
       ${LIBDIR}/materialx/bin/MaterialXGenMdl_d.dll
       ${LIBDIR}/materialx/bin/MaterialXGenOsl_d.dll
       ${LIBDIR}/materialx/bin/MaterialXGenShader_d.dll
+      ${LIBDIR}/materialx/bin/MaterialXRender_d.dll
+      ${LIBDIR}/materialx/bin/MaterialXRenderHw_d.dll
+      ${LIBDIR}/materialx/bin/MaterialXRenderGlsl_d.dll
     DEBUG
   )