Supporting Render Engines in Node Spaces

Table of Contents

• Code
• Final Code

Describes how to associate a node space with the supported render engines.

Code

The supported render engines are defined by storing a list of their plugin identifiers in a BaseArray. This BaseArray is then stored in the maxon::nodes::NODESPACE::RENDERERS setting in NodeRendererNodeSpaceImpl::Init(). This entails that switching the active render engine to a supported render engine will now automatically switch the current node space as well.

  // Defines the supported render 
  // Create a BaseArray that store the supporter's engine ID.
  maxon::BaseArray<maxon::Int> supportedRenderers;
  // Here, g_nodeRendererId is the ID of a render engine.
  supportedRenderers.Append(g_nodeRendererId) iferr_return;
  supportedRenderers.Append(1023342) iferr_return;
  supportedRenderers.Append(0) iferr_return;
  // Add the array in the DataDictionnary.
  spaceData.Set(maxon::nodes::NODESPACE::RENDERERS, std::move(supportedRenderers)) iferr_return;

Final Code

If all the steps have been followed, the code should look like the following:

#include "maxon/datadescriptiondefinitiondatabase.h"
#include "maxon/module.h"
#include "maxon/node_spaces.h"
#include "maxon/nodes_corenodes_base.h"
#include "maxon/previewimageprovider.h"
#include "maxon/datadescription_nodes.h"
#include "maxon/datadescriptiondatabase.h"
#include "maxon/nodeslib.h"
 
 
 
static maxon::nodes::NodeSystemClass g_nodeSystemClass;
 
// This description processor has to be used for all nodes of the example namespace unless they register themselves at the BuiltinNodes registry (such as DynamicNode).
MAXON_DECLARATION_REGISTER(maxon::DescriptionProcessors, "net.maxonexample.handbook.nodespace.noderendererprocessor")
{
  return maxon::nodes::NodesLib::CreateNodeDescriptionProcessor([] (const maxon::Id& descriptionId, const maxon::DataDescription& dataDescription) -> maxon::Result<maxon::nodes::NodeTemplate>
  {
    return maxon::nodes::NodesLib::CreateLazyTemplate(descriptionId,
      [descriptionId]() -> maxon::Result<maxon::nodes::NodeTemplate>
      {
        return maxon::nodes::NodesLib::BuildNodeFromDescription(descriptionId, g_nodeSystemClass);
      }, g_nodeSystemClass);
  });
}
 
 
 
 
 
static maxon::Result<void> ConfigurePreviewImageRequest(maxon::DataDictionaryObjectRef request)
{
  iferr_scope;
 
  request.Set(maxon::nodes::PREVIEWIMAGEREQUEST::PROVIDER, PreviewImageProviderExampleHandbook::GetClass()) iferr_return;
  return maxon::OK;
}
 
 
MAXON_METHOD maxon::Result<void> NodeRendererNodeSpaceImpl::Init(maxon::DataDictionary spaceData)
{
  iferr_scope;
  _class = NodeRendererNodeSystemClassImpl::GetClass().Create() iferr_return;
  spaceData.Set(maxon::nodes::NODESPACE::NODESYSTEMCLASS, _class) iferr_return;
 
  
  
  
  // Defines the End Node for this node systems
  maxon::BaseArray<maxon::Id> materialEndNodeIds;
  // Define the node we want to be defined as the end node.
  materialEndNodeIds.Append(maxon::Id("net.maxonexample.handbook.noderenderer.usernode_shade")) iferr_return;
  // Define the information in the DataDictionnary.
  spaceData.Set(maxon::nodes::NODESPACE::MATERIALENDNODEIDS, std::move(materialEndNodeIds)) iferr_return;
  
  // Defines the supported render 
  // Create a BaseArray that store the supporter's engine ID.
  maxon::BaseArray<maxon::Int> supportedRenderers;
  // Here, g_nodeRendererId is the ID of a render engine.
  supportedRenderers.Append(g_nodeRendererId) iferr_return;
  supportedRenderers.Append(1023342) iferr_return;
  supportedRenderers.Append(0) iferr_return;
  // Add the array in the DataDictionnary.
  spaceData.Set(maxon::nodes::NODESPACE::RENDERERS, std::move(supportedRenderers)) iferr_return;
 
  super.Init(spaceData) iferr_return;
  return maxon::OK;
}
 
 
static maxon::Id g_nodeRendererDatabaseID = maxon::Id("net.maxonexample.handbook.nodes.registereddatabase");
 
static maxon::GenericData g_exampleNodeSpace;
 
static maxon::Result<void> LoadResources()
{
  iferr_scope_handler
  {
    err.CritStop();
    return err;
  };
  // Get plugin location
  const maxon::Url& binaryUrl = maxon::g_maxon.GetUrl();
  // Get plugin folder
  maxon::Url pluginDir = binaryUrl.GetDirectory();
  // Get resource folder (this folder must exist)
  const maxon::Url resourceUrl = pluginDir.Append("res"_s).Append("nodes"_s) iferr_return;
  // Register database
  maxon::DataDescriptionDefinitionDatabaseInterface::RegisterDatabaseWithUrl(g_nodeRendererDatabaseID, resourceUrl) iferr_return;
  // Register the node space
  // Use the same ID as in the resource files
  const maxon::Id spaceDescriptionId = maxon::Id("net.maxonexample.handbook.nodespace.node_renderer");
  // Load the description
  maxon::DataDictionary nodeRendererData = maxon::nodes::NodeSpaceHelpersInterface::LoadDescription(spaceDescriptionId) iferr_return;
 
  maxon::nodes::NodeSpaceRef nodeRendererSpace = NodeRendererNodeSpaceImpl::CreateInit(nodeRendererData) iferr_return;
   
  // Register the node space implementation
  g_exampleNodeSpace = maxon::nodes::MaterialNodeSpaces::Register(NodeRendererNodeSpaceImpl::GetDescriptor().GetId(), nodeRendererSpace) iferr_return;
  
 
  return maxon::OK;
}
 
static void FreeResources()
{
  iferr_scope_handler
  {
    err.CritStop();
    return;
  };
  // Unregister a database
  maxon::DataDescriptionDefinitionDatabaseInterface::UnregisterDatabase(g_nodeRendererDatabaseID) iferr_return;
  g_exampleNodeSpace = maxon::GenericData();
  g_nodeSystemClass = nullptr;
}
MAXON_INITIALIZATION(LoadResources, FreeResources);