Python SDK example for Cinema 4D 2024.5.0

Author: maxon-madam

plugins/py-texture_baker_r18/py-texture_baker_r18.pyp

@@ -74,15 +74,16 @@ class TextureBakerThread(c4d.threading.C4DThread):
         self.bakeData = bakeData
 
         # Initializes bake process
-        bakeInfo = c4d.utils.InitBakeTexture(self.doc, self.textags, self.texuvws, self.destuvws, self.bakeData, self.Get())
+        bakeInfo = c4d.utils.InitBakeTexture(self.doc, self.textags, self.texuvws, self.destuvws, 
+                                             self.bakeData, self.Get())
         self.bakeDoc = bakeInfo[0]
         self.bakeError = bakeInfo[1]
 
         if self.bakeError != c4d.BAKE_TEX_ERR_NONE or self.bakeDoc is None:
             return False
 
         # Starts bake thread
-        self.Start(c4d.THREADMODE_ASYNC, c4d.THREADPRIORITEXY_BELOW)
+        self.Start(c4d.THREADMODE_ASYNC, c4d.THREADPRIORITYEX_BELOW)
 
         return True
 
@@ -93,7 +94,8 @@ class TextureBakerThread(c4d.threading.C4DThread):
 
     def Main(self):
         # Bake Texture Thread Main routine
-        self.bakeError = c4d.utils.BakeTexture(self.bakeDoc, self.bakeData, self.bakeBmp, self.Get(), self.BakeTextureHook)
+        self.bakeError = c4d.utils.BakeTexture(self.bakeDoc, self.bakeData, self.bakeBmp, self.Get(), 
+                                               self.BakeTextureHook)
 
         # Sends core message once baking has finished
         c4d.SpecialEventAdd(PLUGIN_ID)

scripts/04_3d_concepts/modeling/geometry/geometry_splineobject_s26.py

@@ -262,7 +262,7 @@ def main(doc: c4d.documents.BaseDocument) -> None:
         doc: The active document.
     """
     # Run the example constructing the two spline objects.
-    linSpline, bezSpline = ConstructSplineObject(doc)
+    linSpline, bezSpline = ConstructSplineObject()
 
     # Insert both spline objects into the document wrapped into an undo.
     if not doc.StartUndo():

scripts/04_3d_concepts/simulation/particle_group_object_2024_4.py

@@ -10,15 +10,6 @@
 particle group object, press play to simulate the particles, and then run the script. The script 
 will print selected particle data and create null objects representing these particles in the scene.
 
-Note:
-    - The method ParticleGroupObject.GetAttributeChannelData() is currently bugged for the color and 
-      alignment channels. We must use here the specialized functions GetParticleColorsR and
-      GetParticleAlignmentsR. This will be fixed in a future version of Cinema 4D.
-    - The setter c4d.Quaternion.v is currently bugged. This will be fixed in a future version of
-      Cinema 4D. But this makes it currently impossible to construct a c4d.Quaternion from the
-      maxon::Quaternion32 data exposed by the particle system. As a workaround, we can construct
-      a particle alignment from the particle velocity.
-
 See Also:
     - Python Software Foundation (2024). struct module: Formatting Characters. 
       url: https://docs.python.org/3/library/struct.html#format-characters
@@ -30,12 +21,13 @@
 __version__ = "2024.4"
 
 import c4d
+import maxon
 import pprint
 import struct
 import mxutils
 
 doc: c4d.documents.BaseDocument  # The currently active document.
-op: c4d.BaseObject | None # The primary selected object in `doc`. Can be `None`.
+op: c4d.BaseObject | None  # The primary selected object in `doc`. Can be `None`.
 
 
 def GetParticleInfo(op: c4d.ParticleGroupObject, channel: str) -> dict:
@@ -160,52 +152,38 @@ def GetParticleColors(op: c4d.ParticleGroupObject) -> list[c4d.Vector4d]:
 
     More of the same, but here we have a four component vector.
     """
-    # GetAttributeChannelData is currently bugged for the color channel, we must use the specialized
-    # function here for now.
-
-    # colBuffer: memoryview = op.GetAttributeChannelData("net.maxon.particles.attribute.color")
-    colBuffer: memoryview = op.GetParticleColorsR()
+    colBuffer: memoryview = op.GetAttributeChannelData("net.maxon.particles.attribute.color")
     if colBuffer is None:
         return []
 
     info: dict = GetParticleInfo(op, "net.maxon.particles.attribute.color")
     stride: int = info["Data Stride in bytes"]
 
-    return [c4d.Vector4d(*struct.unpack_from("ffff", colBuffer, i))
+    return [maxon.ColorA(*struct.unpack_from("ffff", colBuffer, i))
             for i in range(0, len(colBuffer), stride)]
 
 
 def GetParticleAlignments(op: c4d.ParticleGroupObject) -> list[tuple]:
-    """Unpacks the particle alignments. 
+    """Unpacks the particle alignments.
 
     The alignments are expressed as maxon.Quaternion32. Note that this type is NOT identical to
     c4d.Quaternion.
     """
-    # GetAttributeChannelData is currently bugged for the alignment channel, we must use the
-    # specialized function here for now.
-
-    # alignBuffer: memoryview = op.GetAttributeChannelData("net.maxon.particles.attribute.alignments")
-    alignBuffer: memoryview = op.GetParticleAlignmentsR()
+    alignBuffer: memoryview = op.GetAttributeChannelData("net.maxon.particles.attribute.alignments")
     if alignBuffer is None:
         return []
 
     info: dict = GetParticleInfo(op, "net.maxon.particles.attribute.alignments")
     stride: int = info["Data Stride in bytes"]
 
-    # Unpack the quaternion data from the buffer into a list of quadruples. It is currently not
-    # possible to construct a c4d.Quaternion from the data, as Quaternion.v is currently bugged.
-    # This will be fixed in a future version of Cinema 4D.
+    # Unpack the quaternion data from the buffer into a list of quadruples.
     quaternions: list[tuple] = []
     for i in range(0, len(alignBuffer), stride):
         x, y, z, w = struct.unpack_from("ffff", alignBuffer, i)
-        quaternions.append((x, y, z, w))
-
-        # In a future version of Cinema 4D, the following code will work. SetAxis cannot be used to
-        # set Quaternion.v, and .w directly.
-        # quat: c4d.Quaternion = c4d.Quaternion()
-        # quat.v = c4d.Vector(x, y, z)
-        # quat.w = w
-        # quaternions.append(quat)
+        quat: c4d.Quaternion = c4d.Quaternion()
+        quat.v = c4d.Vector(x, y, z)
+        quat.w = w
+        quaternions.append(quat)
 
     return quaternions
 
@@ -242,11 +220,6 @@ def main() -> None:
 
     # Construct global transforms for the first five particles and insert null objects for them. See
     # Python API Matrix manual for details of how to construct a matrix from a position and a vector.
-    # It is currently not possible to construct frames for the "true" alignments of particles, as
-    # the Quaternion.v property is bugged. This will be fixed in a future version of Cinema 4D. This
-    # approach is flawed as constructing a frame from one vector lacks information for one of the
-    # three degrees of freedom. The chosen up vector will impact the banking of particles.
-
     transforms: list[tuple[c4d.Vector, c4d.Vector]] = list(zip(positions, velocities))
     length: int = 5 if len(transforms) >= 5 else len(transforms)
     eps: float = 1E-5

scripts/05_modules/node/create_redshift_nodematerial_2024.py

@@ -13,7 +13,7 @@
 """
 __author__ = "Ferdinand Hoppe"
 __copyright__ = "Copyright (C) 2023 MAXON Computer GmbH"
-__date__ = "01/09/2023"
+__date__ = "04/06/2024"
 __license__ = "Apache-2.0 License"
 __version__ = "2024.0.0"
 
@@ -37,45 +37,69 @@ def main() -> None:
     # mix node. These and all other node IDs can be discovered in the node info overlay in the 
     # bottom left corner of the Node Editor. Open the Cinema 4D preferences by pressing CTRL/CMD + E
     # and enable Node Editor -> Ids in order to see node and port IDs in the Node Editor.
+    idOutputNode: maxon.Id = maxon.Id("com.redshift3d.redshift4c4d.node.output")
+    idStandardMaterial: maxon.Id = maxon.Id("com.redshift3d.redshift4c4d.nodes.core.standardmaterial")
     idTextureNode: maxon.Id = maxon.Id("com.redshift3d.redshift4c4d.nodes.core.texturesampler")
     idMixNode: maxon.Id = maxon.Id("com.redshift3d.redshift4c4d.nodes.core.rscolormix")
-    idRsStandardMaterial: maxon.Id = maxon.Id("com.redshift3d.redshift4c4d.nodes.core.standardmaterial")
 
-    # Instantiate a material, get its node material and the graph for the RS material space.
+    # Instantiate a material, get its node material, and add a graph for the RS material space.
     material: c4d.BaseMaterial = c4d.BaseMaterial(c4d.Mmaterial)
     if not material:
         raise MemoryError(f"{material = }")
 
     nodeMaterial: c4d.NodeMaterial = material.GetNodeMaterialReference()
-    graph: maxon.GraphModelRef = nodeMaterial.CreateDefaultGraph(
-        maxon.Id("com.redshift3d.redshift4c4d.class.nodespace"))
+    redshiftNodeSpaceId: maxon.Id =  maxon.Id("com.redshift3d.redshift4c4d.class.nodespace")
+    graph: maxon.GraphModelRef = nodeMaterial.CreateEmptyGraph(redshiftNodeSpaceId)
     if graph.IsNullValue():
-        raise RuntimeError("Could not add RS graph to material.")
-
+        raise RuntimeError("Could not add Redshift graph to material.")
+
+    # Open an undo operation and insert the material into the document. We must do this before we 
+    # modify the graph of the material, as otherwise the viewport material will not correctly display 
+    # the textures of the material until the user manually refreshes the material. It is also 
+    # important to insert the material after we added the default graph to it, as otherwise we will 
+    # end up with two undo steps in the undo stack.
+    if not doc.StartUndo():
+        raise RuntimeError("Could not start undo stack.")
+    
     doc.InsertMaterial(material)
-    c4d.EventAdd()
+    if not doc.AddUndo(c4d.UNDOTYPE_NEWOBJ, material):
+        raise RuntimeError("Could not add undo item.")
 
-    # Attempt to find the core material node contained in the default graph setup.
-    result: list[maxon.GraphNode] = []
-    maxon.GraphModelHelper.FindNodesByAssetId(graph, idRsStandardMaterial, True, result)
-    if len(result) < 1:
-        raise RuntimeError("Could not find RS Standard node in material.")
-    standardNode: maxon.GraphNode = result[0]
+    # Define the user data for the transaction. This is optional, but can be used to tell the Nodes
+    # API to add the transaction to the current undo stack instead of creating a new one. This will
+    # then have the result that adding the material, adding the graph, and adding the nodes will be
+    # one undo step in the undo stack.
+    userData: maxon.DataDictionary = maxon.DataDictionary()
+    userData.Set(maxon.nodes.UndoMode, maxon.nodes.UNDO_MODE.ADD)
 
     # Start modifying the graph by opening a transaction. Node graphs follow a database like 
     # transaction model where all changes are only finally applied once a transaction is committed.
-    with graph.BeginTransaction() as transaction:
+    with graph.BeginTransaction(userData) as transaction:
+
+        # Add the output, i.e., the terminal end node of the graph, as well as a standard material
+        # node to the graph.
+        outNode: maxon.GraphNode = graph.AddChild(maxon.Id(), idOutputNode)
+        materialNode: maxon.GraphNode = graph.AddChild(maxon.Id(), idStandardMaterial)
+
         # Add two texture nodes and a blend node to the graph.
         rustTexNode: maxon.GraphNode = graph.AddChild(maxon.Id(), idTextureNode)
         sketchTexNode: maxon.GraphNode = graph.AddChild(maxon.Id(), idTextureNode)
         mixNode: maxon.GraphNode = graph.AddChild(maxon.Id(), idMixNode)
 
+        # Get the input 'Surface' port of the 'Output' node and the output 'Out Color' port of the
+        # 'Standard Material' node and connect them.
+        surfacePortOutNode: maxon.GraphNode = outNode.GetInputs().FindChild(
+            "com.redshift3d.redshift4c4d.node.output.surface")
+        outcolorPortMaterialNode: maxon.GraphNode = materialNode.GetOutputs().FindChild(
+            "com.redshift3d.redshift4c4d.nodes.core.standardmaterial.outcolor")
+        outcolorPortMaterialNode.Connect(surfacePortOutNode)
+
         # Set the default value of the 'Mix Amount' port, i.e., the value the port has when no 
         # wire is connected to it. This is equivalent to the user setting the value to "0.5" in 
         # the Attribute Manager.
         mixAmount: maxon.GraphNode = mixNode.GetInputs().FindChild(
             "com.redshift3d.redshift4c4d.nodes.core.rscolormix.mixamount")
-        mixAmount.SetDefaultValue(0.5)
+        mixAmount.SetPortValue(0.5)
 
         # Set the path sub ports of the 'File' ports of the two image nodes to the texture URLs 
         # established above. Other than for the standard node space image node, the texture is 
@@ -86,8 +110,8 @@ def main() -> None:
             "com.redshift3d.redshift4c4d.nodes.core.texturesampler.tex0").FindChild("path")
         pathSketchPort: maxon.GraphNode = sketchTexNode.GetInputs().FindChild(
             "com.redshift3d.redshift4c4d.nodes.core.texturesampler.tex0").FindChild("path")
-        pathRustPort.SetDefaultValue(urlTexRust)
-        pathSketchPort.SetDefaultValue(urlTexSketch)
+        pathRustPort.SetPortValue(urlTexRust)
+        pathSketchPort.SetPortValue(urlTexSketch)
 
         # Get the color output ports of the two texture nodes and the color blend node.
         rustTexColorOutPort: maxon.GraphNode = rustTexNode.GetOutputs().FindChild(
@@ -102,7 +126,7 @@ def main() -> None:
             "com.redshift3d.redshift4c4d.nodes.core.rscolormix.input1")
         mixInput2Port: maxon.GraphNode = mixNode.GetInputs().FindChild(
             "com.redshift3d.redshift4c4d.nodes.core.rscolormix.input2")
-        stdBaseColorInPort: maxon.GraphNode = standardNode.GetInputs().FindChild(
+        stdBaseColorInPort: maxon.GraphNode = materialNode.GetInputs().FindChild(
             "com.redshift3d.redshift4c4d.nodes.core.standardmaterial.base_color")
 
         # Wire up the two texture nodes to the blend node and the blend node to the BSDF node.
@@ -113,8 +137,9 @@ def main() -> None:
         # Finish the transaction to apply the changes to the graph.
         transaction.Commit()
 
-    # Insert the material into the document and push an update event.
-    doc.InsertMaterial(material)
+    if not doc.EndUndo():
+        raise RuntimeError("Could not end undo stack.")
+
     c4d.EventAdd()
 
 if __name__ == "__main__":