'Octane Renderer' menu settings not appearing when I switch render data to octane with python.

lionlion44

I am trying to switch the renderer to octane using python, I've achieved this with the following:

ID_OCTANE_RENDERER = 1036219
render_data = doc.GetActiveRenderData()
render_data[c4d.RDATA_RENDERENGINE] = ID_OCTANE_RENDERER
c4d.EventAdd()

However if I do this to a fresh document it doesn't seem to initialise some settings. The 'Octane Renderer' menu item doesn't appear unless I switch back and forth to a different renderer manually.
What I want:

What I get:

Is there anything else that happens when you set the renderer manually that I need to account for?
Thanks

lionlion44

I have found what seems like a solution:

ID_OCTANE_RENDERER = 1029525
render_data = doc.GetActiveRenderData()
render_data.InsertVideoPostLast(c4d.documents.BaseVideoPost(ID_OCTANE_RENDERER))
render_data[c4d.RDATA_RENDERENGINE] = ID_OCTANE_RENDERER
c4d.EventAdd()

I just needed to insert the video post. I am yet to test it, but it at least looks correct.

ferdinand

Hey @lionlion44,

Thank you for reaching out to us. We cannot provide support on third party libraries (Octane). But, yes, in general you are on the right track. We have this C++ example, which I loosely translated to Python. The thing to do which you are missing, is to check if such VP already exists, as you otherwise can land in a world of hurt.

For everything else, you would have to talk with the Octane devs (of which some are here on this forum), if there are any special further steps to be taken for Octane.

Cheers,
Ferdinand

"""Provides an example for generically setting a render engine in Cinema 4D.

Note that there is no guarantee that every render engine has a video post node, and when it has one,
that it uses the same ID as the render engine. But it is highly conventional to implement a render
engine like this.

Derived from the C++ Example "Set Render Engine to Redshift": 

    https://developers.maxon.net/docs/cpp/2023_2/page_manual_redshift_rendrer.html

"""

import c4d
import mxutils

doc: c4d.documents.BaseDocument # The active Cinema 4D document.

def SetRenderEngine(doc: c4d.documents.BaseDocument, newEngineId: int, createsVideoPostNode: bool) -> bool:
    """Sets the render engine of the given document to the specified ID.
    """
    # Make sure we are on the main thread, as we plan to modify the document and ensure that our
    # inputs are what we think they are.
    if not c4d.threading.GeIsMainThread():
        raise RuntimeError("SetRenderEngine must be called from the main thread.")

    mxutils.CheckType(doc, c4d.documents.BaseDocument)
    mxutils.CheckType(newEngineId, int)
    mxutils.CheckType(createsVideoPostNode, bool)

    # Get the currently active render engine ID and get out if it matches the new one.
    renderData: c4d.documents.RenderData = doc.GetActiveRenderData()
    currentEngineId: int = renderData[c4d.RDATA_RENDERENGINE]
    if currentEngineId == newEngineId:
        print(f"Render engine {newEngineId} is already set, no changes made.")
        return True
    
    # Try to find a video post with the render engine ID. There is no absolute guarantee that every
    # render engine either has a video post node or that is gives it the same ID as the render 
    # engine (but it is strongly conventional).
    if createsVideoPostNode:
        # Try to find an already existing video post node with the render engine ID.
        node: c4d.documents.BaseVideoPost | None = renderData.GetFirstVideoPost()
        while node:
            if node.GetType() == newEngineId:
                break
            node = node.GetNext()

        # There is no video post for the render engine, so we try to a new create one.
        if not node:
            try:
                node: c4d.documents.BaseVideoPost = c4d.documents.BaseVideoPost(newEngineId)
                renderData.InsertVideoPost(node)
            except Exception as e:
                raise RuntimeError(f"Failed to create video post node for render engine {newEngineId} ({e}).")
    
    # Finally, we set the render engine ID in the render data.
    renderData[c4d.RDATA_RENDERENGINE] = newEngineId
    return True

def main() -> None:
    """Called by Cinema 4D to run the script.
    """
    # Setting the standard render engine, here we do not have to create a video post node, since
    # the standard renderer is one of the rare cases that does not have a dedicated video post.
    SetRenderEngine(doc, newEngineId=c4d.RDATA_RENDERENGINE_STANDARD, createsVideoPostNode=False)

    # Set Redshift as the render engine, which does have a video post node.
    SetRenderEngine(doc, newEngineId=c4d.VPrsrenderer, createsVideoPostNode=True)

    # Push an update event.
    c4d.EventAdd()

if __name__ == "__main__":
    main()