BogdanNagirniak/blender
0
0
Fork 3
forked from blender/blender
Code Pull Requests Activity

BLEN-299: Export instances #11

Merged
Bogdan Nagirniak merged 7 commits from BLEN-299 into hydra-render 2023-03-05 09:37:12 +01:00
Conversation 0 Commits 7 Files Changed 7 +306 -39
28 changed files with 306 additions and 39 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 29b934dbb5 - Show all commits

2
CMakeLists.txt
View File

@ -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()

7
build_files/cmake/platform/platform_win32.cmake
View File

@ -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/*.*" )

12
source/blender/render/hydra/CMakeLists.txt
View File

@ -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)

1
source/blender/render/hydra/engine.h
View File

@ -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();

4
source/blender/render/hydra/finalEngine.cc
View File

@ -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) {

4
source/blender/render/hydra/finalEngine.h
View File

@ -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 render(BL::Depsgraph &b_depsgraph);
virtual void sync(BL::Depsgraph &b_depsgraph, BL::Context &b_context, pxr::HdRenderSettingsMap &renderSettings) override;
virtual void render(BL::Depsgraph &b_depsgraph) override;
protected:
pxr::GfVec2i get_resolution(BL::RenderSettings b_render);

77
source/blender/render/hydra/previewEngine.cc Normal file
View File

@ -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

23
source/blender/render/hydra/previewEngine.h Normal file
View File

@ -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

10
source/blender/render/hydra/python.cc
View File

@ -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;

3
source/blender/render/hydra/sceneDelegate/blenderSceneDelegate.cc
View File

@ -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)

10
source/blender/render/hydra/sceneDelegate/blenderSceneDelegate.h
View File

@ -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);

3
source/blender/render/hydra/sceneDelegate/id.cc
View File

@ -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)
{

6
source/blender/render/hydra/sceneDelegate/id.h
View File

@ -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;
};

8
source/blender/render/hydra/sceneDelegate/light.cc
View File

@ -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) {

2
source/blender/render/hydra/sceneDelegate/light.h
View File

@ -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;

22
source/blender/render/hydra/sceneDelegate/material.cc
View File

@ -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();
}

6
source/blender/render/hydra/sceneDelegate/material.h
View File

@ -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 pxr::SdfPath prim_id(pxr::HdSceneDelegate *scene_delegate, Material *material);
static std::unique_ptr<MaterialData> init(BlenderSceneDelegate *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;

3
source/blender/render/hydra/sceneDelegate/mesh.cc
View File

@ -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 &&

2
source/blender/render/hydra/sceneDelegate/mesh.h
View File

@ -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;

77
source/blender/render/hydra/sceneDelegate/mtlxHydraAdapter.cc Normal file
View File

@ -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

20
source/blender/render/hydra/sceneDelegate/mtlxHydraAdapter.h Normal file
View File

@ -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

7
source/blender/render/hydra/sceneDelegate/object.cc
View File

@ -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)
{

6
source/blender/render/hydra/sceneDelegate/object.h
View File

@ -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 pxr::SdfPath prim_id(pxr::HdSceneDelegate *scene_delegate, Object *object);
static std::unique_ptr<ObjectData> init(BlenderSceneDelegate *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();

7
source/blender/render/hydra/sceneDelegate/world.cc
View File

@ -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;

6
source/blender/render/hydra/sceneDelegate/world.h
View File

@ -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 pxr::SdfPath prim_id(pxr::HdSceneDelegate *scene_delegate);
static std::unique_ptr<WorldData> init(BlenderSceneDelegate *scene_delegate, World *world, bContext *context);
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();

8
source/blender/render/hydra/viewportEngine.cc
View File

@ -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());

3
source/blender/render/hydra/viewportEngine.h
View File

@ -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);

6
source/creator/CMakeLists.txt
View File

@ -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
)