Hi,

thanks for the kind words both from Maxon and the community. I am looking forward to my upcoming adventures with the SDK Team and Cinema community.

Cheers,
Ferdinand

Hi,

as @Cairyn said the problem is unreachable code. I also just saw now that you did assign the same ID to all your buttons in your CreateLayout(). Ressource and dialog element IDs should be unique. I would generally recommend to define your dialogs using a resource, but here is an example on how to do it in code.

BUTTON_BASE_ID = 1000
BUTTON_NAMES = ["Button1", "Button2", "Button3", "Button4", "Button5"]
BUTTON_DATA = {BUTTON_BASE_ID + i: name for i, name in enumerate(BUTTON_NAMES)}

class MyDialog(gui.GeDialog):

    def CreateLayout(self):
        """
        """
        self.GroupBegin(id=1013, flags=c4d.BFH_SCALEFIT, cols=5, rows=4)
        for element_id, element_name in BUTTON_DATA.items():
            self.AddButton(element_id, c4d.BFV_MASK, initw=100, 
                           name=element_name)
        self.GroupEnd()
        return True

    def Command(self, id, msg):
        """
        """
        if id == BUTTON_BASE_ID:
            print "First button has been clicked"
        elif id == BUTTON_BASE_ID + 1:
            print "Second button has been clicked"
        # ...
        if id in BUTTON_DATA.keys(): # or just if id in BUTTON_DATA
            self.Close()
        return True

Hi,

that your script is not working has not anything to do with pseudo decimals, but the fact that you are treating numbers as strings (which is generally a bad idea) in a not very careful manner. When you truncate the string representation of a number which is represented in scientific notation (with an exponent), then you also truncate that exponent and therefor change the value of the number.

To truncate a float you can either take the floor of my_float * 10 ** digits and then divide by 10 ** digits again or use the keyword round.

data = [0.03659665587738824,
        0.00018878623163019122,
        1.1076812650509394e-03,
        1.3882258325566638e-06]

for n in data:
    rounded = round(n, 4)
    floored = int(n * 10000) / 10000
    print(n, rounded, floored)

0.03659665587738824 0.0366 0.0365
0.00018878623163019122 0.0002 0.0001
0.0011076812650509394 0.0011 0.0011
1.3882258325566637e-06 0.0 0.0
[Finished in 0.1s]

Cheers
zipit

Hi,

sorry for all the confusion. You have to pass actual instances of objects. The following code does what you want (and this time I actually tried it myself ;)).

import c4d

def main():
    """
    """
    bc = doc.GetAllTextures(ar=doc.GetMaterials())
    for cid, value in bc:
        print cid, value

if __name__=='__main__':
   main()

Cheers,
zipit

Hi,

the nature of your problem remains a bit unclear to me. You talk about polygonal data and beveling edges, which I would interpret as the question for bevelling in a network of curves, .e.g. a polygonal topology, but you show the image of a curve and also your code operates in a plane. I assume you want interpret your mesh as a series of cross-sections/curves?

That aside, beveling (either curves or curves in surfaces, i.e. edges) is an application of interpolation and can therefor implemented in various forms, here are some approaches:

1. Piecing in arc segments. This what you are basically trying to do from the looks of your code. You normally would properly define a series of transforms (i.e. "matrices" in Cinema) to transform a base vector and by that construct the vertices making up the arc segment. This solution is not very suited for a data of intersecting curve networks, i.e. surfaces, it works better in something like a 2D Vector app.

2. Than there are multiple ways to construct a smooth curve over a series points. The easiest one are Chaikin's Curves which also have spawned a whole group of algorithms all following more or less the same one fourth three fourth idea and some of them can also be applied to meshes.

3. The next obvious candidates would be quadratic or cubic polynomials/curves. They can the can also be viewed as a combination of linear interpolations. This is called De Casteljau's algorithm. To get from multiple curves segments to splines, you just piece them together (there are multiple ways to do this). But in you case of beveling you probably will only need a single curve. Depending on how deep you venture into this topic this reaches from splines and curves (.e.g. a B-Spline or a Bezier spline) to surfaces (e.g. a NURBS surface).

4. The last one, and that is the one Cinema probably uses for its edge tool is just Subdivision Surfaces. There are also multiple algorithms of varying complexity, but classical Catmull-Clark SDS have very nice properties (producing only quads for example) and are very easy to implement. The problem here is how to restrict the subdivision part of the algorithm so that you only generate new edges along the edge loop and not perpendicular to it and then come up with the correct modified weights for the smoothing.

Its all a bit vague, but your question is very broad, so I thought this might help.

edit: Forgot this, but should have put this first - Implementing a bevel tool is not trivial. Covering the default case is not that hard, but covering all the corner cases is, especially when you want to maintain secondary mesh attributes like texture coordinates. I would not go for reinventing the wheel here. Is there a reason why you do not want to use Cinema's edge bevel? Does it not work with SendModellingCommand?

Cheers,
zipit

Hi,

you use GetActiveDocument() in a NodeData environment. You cannot do this, since nodes are also executed when their document is not the active document (while rendering for example - documents get cloned for rendering).

Cheers
zipit

Hoi,

@blastframe said in Moving a Point Along an Arc by Distance from another Point:

• In your code comment you mention spherical interpolation between the arc segment. Is that the same as the quadratic bezier interpolation from the example you provided (code below)? I think that's also called slerp?

Yeah, slerp is a synonym for spherical linear interpolation. While linear interpolation, a.k.a. lerp, gives you points on the line segment spanned by its two input vectors, a spherical linear interpolation gives you points on the arc segment spanned between the unit vectors of the two input vectors. Cinema does not have a slerp for vectors for some reason, only one for quaternions. The whole interpolation and interpolation naming situation in Cinema's classic API is a huge mess IMHO. So you would have to write your own slerp. And slerp is not directly related to splines, only in the sense that you will need it when you want to linearly place points on that spline, as you then have to do the arc-length parametrization of that spline for which you will need slerp.

• How do I get the points to stop at the limits of the arc? In this case, it would seem to be limiting the angle to 0 and math.pi, but what if the start & end angles are different?

Basically the same way you did it in your code. The computed angle is an angle in radians. So to limit it to let's say [0°, 180°] you would have to clamp it to [0 rad,π rad]. There is also the problem that angles work the other way around in relation to the circle functions sine and cosine and your example. They "start on the right side" of the unit circle and then go counter clockwise. Which is why my code flips things around. Getting back to "your setup" should just a matter of inverting the angle, i.e. -theta instead of theta, and then adding π, i.e. 180°.

• If I'm not to use c4d.Vector.GetDistance, how would you recommend I get the geodesic norm? I found modules online like geopy, but I'd rather do it with standard Python.

Its the same thing in green. You get the Euclidean norm, a.k.a the "length" of your vectors, implying the radius of the circle they are sitting on. Then you can compute the angle spanned between them with the dot product. Finally you put this into the relation shown above, solve for the arc length and you are done. And to be clear, Geodesic norm is just a fancy name for saying the distance between two points on a sphere, while the Euclidean norm is the distance in a plane.

Cheers,
zipit

Hi,

you have to invoke AddUserArea and then attach an instance of your implemented type to it. Something like this:

my_user_area = MyUserAreaType()
self.AddUserArea(1000,*other_arguments)
self.AttachUserArea(my_user_area, 1000)

I have attached an example which does some things you are trying to do (rows of things, highlighting stuff, etc.). The gadget is meant to display a list of boolean values and the code is over five years old. I had a rather funny idea of what good Python should look like then and my attempts of documentation were also rather questionable. I just wrapped the gadget into a quick example dialog you could run as a script. I did not maintain the code, so there might be newer and better ways to do things now.

Also a warning: GUI stuff is usually a lot of work and very little reward IMHO.

Cheers
zipit

import c4d
import math
import random

from c4d import gui

# Pattern Gadget
IDC_SELECTLOOP_CELLSIZE = [32, 32]
IDC_SELECTLOOP_GADGET_MINW = 400
IDC_SELECTLOOP_GADGET_MINH = 32

class ExampleDialog(gui.GeDialog):
    """
    """
    def CreateLayout(self):
        """
        """

        self.Pattern = c4d.BaseContainer()
        for i in range(10):
            self.Pattern[i] = random.choice([True, False])
        self.PatternSize = len(self.Pattern)

        self.gadget = Patterngadget(host=self)
        self.AddUserArea(1000, c4d.BFH_FIT, 400, 32)
        self.AttachUserArea(self.gadget, 1000)
        return True

class Patterngadget(gui.GeUserArea):
    """
    A gui gadget to modify and display boolean patterns.
    """

    def __init__(self, host):
        """
        :param host: The hosting BaseToolData instance
        """
        self.Host = host
        self.BorderWidth = None
        self.CellPerColumn = None
        self.CellWidht = IDC_SELECTLOOP_CELLSIZE[0]
        self.CellHeight = IDC_SELECTLOOP_CELLSIZE[1]
        self.Columns = None
        self.Height = None
        self.Width = None
        self.MinHeight = IDC_SELECTLOOP_GADGET_MINH
        self.MinWidht = IDC_SELECTLOOP_GADGET_MINW
        self.MouseX = None
        self.MouseY = None

    """------------------------------------------------------------------------
        Overridden methods
        --------------------------------------------------------------------"""

    def Init(self):
        """
        Init the gadget.
        :return : Bool
        """
        self._get_colors()
        return True

    def GetMinSize(self):
        """
        Resize the gadget
        :return : int, int
        """
        return int(self.MinWidht), int(self.MinHeight)

    def Sized(self, w, h):
        """
        Get the gadgets height and width
        """
        self.Height, self.Width = int(h), int(w)
        self._fit_gadget()

    def Message(self, msg, result):
        """
        Fetch and store mouse over events
        :return : bool
        """
        if msg.GetId() == c4d.BFM_GETCURSORINFO:
            base = self.Local2Screen()
            if base:
                self.MouseX = msg.GetLong(c4d.BFM_DRAG_SCREENX) - base['x']
                self.MouseY = msg.GetLong(c4d.BFM_DRAG_SCREENY) - base['y']
                self.Redraw()
                self.SetTimer(1000)
        return gui.GeUserArea.Message(self, msg, result)

    def InputEvent(self, msg):
        """
        Fetch and store mouse clicks
        :return : bool
        """
        if not isinstance(msg, c4d.BaseContainer):
            return True
        if msg.GetLong(c4d.BFM_INPUT_DEVICE) == c4d.BFM_INPUT_MOUSE:
            if msg.GetLong(c4d.BFM_INPUT_CHANNEL) == c4d.BFM_INPUT_MOUSELEFT:
                base = self.Local2Global()
                if base:
                    x = msg.GetLong(c4d.BFM_INPUT_X) - base['x']
                    y = msg.GetLong(c4d.BFM_INPUT_Y) - base['y']
                    pid = self._get_id(x, y)
                    if pid <= self.Host.PatternSize:
                        self.Host.Pattern[pid] = not self.Host.Pattern[pid]
                        self.Redraw()
        return True

    def Timer(self, msg):
        """
        Timer loop to catch OnMouseExit
        """
        base = self.Local2Global()
        bc = c4d.BaseContainer()
        res = gui.GetInputState(c4d.BFM_INPUT_MOUSE,
                                c4d.BFM_INPUT_MOUSELEFT, bc)
        mx = bc.GetLong(c4d.BFM_INPUT_X) - base['x']
        my = bc.GetLong(c4d.BFM_INPUT_Y) - base['y']
        if res:
            if not (mx >= 0 and mx <= self.Width and
                    my >= 0 and my <= self.Height):
                self.SetTimer(0)
                self.Redraw()

    def DrawMsg(self, x1, y1, x2, y2, msg):
        """
        Draws the gadget
        """
        # double buffering
        self.OffScreenOn(x1, y1, x2, y2)
        # background & border
        self.DrawSetPen(self.ColBackground)
        self.DrawRectangle(x1, y1, x2, y2)
        if self.BorderWidth:
            self.DrawBorder(c4d.BORDER_THIN_IN, x1, y1,
                            self.BorderWidth + 2, y2 - 1)
        # draw pattern
        for pid, state in self.Host.Pattern:
            x, y = self._get_rect(pid)
            self._draw_cell(x, y, state, self._is_focus(x, y))

    """------------------------------------------------------------------------
        Public methods
        --------------------------------------------------------------------"""

    def Update(self, cid=None):
        """
        Update the gadget.
        :param cid: A pattern id to toggle.
        """
        if cid and cid < self.Host.PatternSize:
            self.Host.Pattern[cid] = not self.Host.Pattern[cid]
        self._fit_gadget()
        self.Redraw()

    """------------------------------------------------------------------------
        Private methods
        --------------------------------------------------------------------"""

    def _get_colors(self, force=False):
        """
        Set the drawing colors.
        :return : Bool
        """
        self.ColScale = 1.0 / 255.0
        if self.IsEnabled() or force:
            self.ColBackground = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellActive = c4d.GetViewColor(
                c4d.VIEWCOLOR_ACTIVEPOINT) * 0.9
            self.ColCellFocus = self._get_color_vector(c4d.COLOR_BGFOCUS)
            self.ColCellInactive = self._get_color_vector(c4d.COLOR_BGEDIT)
            self.ColEdgeDark = self._get_color_vector(c4d.COLOR_EDGEDK)
            self.ColEdgeLight = self._get_color_vector(c4d.COLOR_EDGELT)
        else:
            self.ColBackground = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellActive = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellFocus = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellInactive = self._get_color_vector(c4d.COLOR_BG)
            self.ColEdgeDark = self._get_color_vector(c4d.COLOR_EDGEDK)
            self.ColEdgeLight = self._get_color_vector(c4d.COLOR_EDGELT)
        return True

    def _get_cell_pen(self, state, _is_focus):
        """
        Get the color for cell depending on its state.
        :param state   : The state
        :param _is_focus : If the cell is hoovered.
        :return        : c4d.Vector()
        """
        if state:
            pen = self.ColCellActive
        else:
            pen = self.ColCellInactive
        if self.IsEnabled() and _is_focus:
            return (pen + c4d.Vector(2)) * 1/3
        else:
            return pen

    def _draw_cell(self, x, y, state, _is_focus):
        """
        Draws a gadget cell.
        :param x:       local x
        :param y:       local y
        :param state:   On/Off
        :param _is_focus: MouseOver state
        """
        # left and top bright border
        self.DrawSetPen(self.ColEdgeLight)
        self.DrawLine(x, y, x + self.CellWidht, y)
        self.DrawLine(x, y, x, y + self.CellHeight)
        # bottom and right dark border
        self.DrawSetPen(self.ColEdgeDark)
        self.DrawLine(x, y + self.CellHeight - 1, x +
                      self.CellWidht - 1, y + self.CellHeight - 1)
        self.DrawLine(x + self.CellWidht - 1, y, x +
                      self.CellWidht - 1, y + self.CellHeight - 1)
        # cell content
        self.DrawSetPen(self._get_cell_pen(state, _is_focus))
        self.DrawRectangle(x + 1, y + 1, x + self.CellWidht -
                           2, y + self.CellHeight - 2)

    def _get_rect(self, pid, offset=1):
        """
        Get the drawing rect for an array id.
        :param pid    : the pattern id
        :param offset : the pixel border offset
        :return       : int, int
        """
        pid = int(pid)
        col = pid / self.CellPerColumn
        head = pid % self.CellPerColumn
        return self.CellWidht * head + offset, self.CellHeight * col + offset

    def _get_id(self, x, y):
        """
        Get the array id for a coord within the gadget.
        :param x : local x
        :param y : local y
        :return  : int
        """
        col = (y - 1) / self.CellHeight
        head = (x - 1) / self.CellWidht
        return col * self.CellPerColumn + head

    def _is_focus(self, x, y):
        """
        Test if the cell coords are under the cursor.
        :param x : local x
        :param y : local y
        :return  : bool
        """
        if (self.MouseX >= x and self.MouseX <= x + self.CellWidht and
                self.MouseY >= y and self.MouseY <= y + self.CellHeight):
            self.MouseX = c4d.NOTOK
            self.MouseY = c4d.NOTOK
            return True
        else:
            return False

    def _fit_gadget(self):
        """
        Fit the gadget size to the the array
        """
        oldHeight = self.MinHeight
        self.CellPerColumn = int((self.Width - 2) / self.CellWidht)
        self.Columns = math.ceil(
            self.Host.PatternSize / self.CellPerColumn) + 1
        self.MinHeight = int(IDC_SELECTLOOP_GADGET_MINH * self.Columns) + 3
        self.MinWidht = int(IDC_SELECTLOOP_GADGET_MINW)
        self.BorderWidth = self.CellWidht * self.CellPerColumn
        if oldHeight != self.MinHeight:
            self.LayoutChanged()

    def _get_color_vector(self, cid):
        """
        Get a color vector from a color ID.
        :param cid : The color ID
        :return    : c4d.Vector()
        """
        dic = self.GetColorRGB(cid)
        if dic:
            return c4d.Vector(float(dic['r']) * self.ColScale,
                              float(dic['g']) * self.ColScale,
                              float(dic['b']) * self.ColScale)
        else:
            return c4d.Vector()

if __name__ == "__main__":
    dlg = ExampleDialog()
    dlg.Open(c4d.DLG_TYPE_ASYNC, defaultw=400, defaulth=400)

Hi @bentraje,

thank you for reaching out to us. As @Cairyn already said, there is little which prevents you from writing your own cloner. Depending on the complexity of the cloner, this can however be quite complex. Just interpolating between two positions or placing objects in a grid array is not too hard. But recreating all the complexity of a MoGraph cloner will be. It is also not necessary. Here are two more straight forward solutions:

1. As I said in the last thread (the one you did link), MoGraph is perfectly capable of driving arbitrary parameters of an object. I overlooked in the old thread that you did ask what I meant with ""drive the attributes of an object or its material"", so the file cube_bend_mograph.c4d shows you how you can drive the strength parameter of a bend object with MoGraph. The difference I then made was that while you cannot drive such attributes directly via the particle (arrays), but you can let MoGraphs interpolation system take care of it. Please keep in mind that I am everything but an expert for MoGraph. There are probably more elegant solutions for all this, but all this is out of scope for this forum. Please contact technical support or refer to Cineversity for questions about MoGraph.
2. One problem of MoGraph is that driving more than one arbitrary parameter of an object is a bit tedious. Since MoGraph's sole principle is interpolation and it can only interpolate on a single axis (between parameters), you will then have to start interpolating between two cloners to drive a second, third, fourth, etc. parameter. Here it would make sense to write a custom solution to have less complicated setups. Rather than rewriting a cloner, it would be however more sensible to just modify the cache of a cloner. This will only work when the cloner is in the "Instance Mode" "Instance", as otherwise the cache will only contain the instance wrappers (a bit confusing the naming here ^^). You could do this all inside a GVO, including building the cloner and its cache, but I did provide here a solution which relies on linking a cloner whose cache one wishes to modify. The idea is then simple, walk over all bend objects in the cache and modify their bend strength. You can find a scene file and the code below.

Cheers,
Ferdinand

file: cube_bend_python.c4d
code:

"""Example for modifying the cache of a node and returning it as the output
of a generator.

This specific example drives the bend strength of bend objects contained in
a Mograph cloner object. The example is designed for a Python generator 
object with a specific set of user data values. Please use the provided c4d
file if possible.

Note:
    This example makes use of the function `CacheIterator()` for cache 
    iteration which has been proposed on other threads for the task of walking
    a cache, looking for specific nodes. One can pass in one or multiple type
    symbols for the node types to be retrieved from the cache. I did not 
    unpack the topic of caches here any further.

    We are aware that robust cache walking can be a complex subject and 
    already did discuss adding such functionality to the SDK toolset in the
    future, but for now users have to do that on their own.

As discussed in:
    plugincafe.maxon.net/topic/13275/
"""

import c4d

# The cookie cutter cache iterator template, can be treated as a black-box,
# as it has little to do with the threads subject.
def CacheIterator(op, types=None):
    """An iterator for the elements of a BaseObject cache.

    Handles both "normal" and deformed caches and has the capability to 
    filter by node type.

    Args:
        op (c4d.BaseObject): The node to walk the cache for.
        types (Union[list, tuple, int, None], optional): A collection of type
         IDs from one of which a yielded node has to be derived from. Will
         yield all node types if None. Defaults to None.

    Yields:
        c4d.BaseObject: A cache element of op.

    Raises:
        TypeError: On argument type violations.
    """
    if not isinstance(op, c4d.BaseObject):
        msg = "Expected a BaseObject or derived class, got: {0}"
        raise TypeError(msg.format(op.__class__.__name__))

    if isinstance(types, int):
        types = (types, )
    if not isinstance(types, (tuple, list, type(None))):
        msg = "Expected a tuple, list or None, got: {0}"
        raise TypeError(msg.format(types.__class__.__name__))

    # Try to retrieve the deformed cache of op.
    temp = op.GetDeformCache()
    if temp is not None:
        for obj in CacheIterator(temp, types):
            yield obj

    # Try to retrieve the cache of op.
    temp = op.GetCache()
    if temp is not None:
        for obj in CacheIterator(temp, types):
            yield obj

    # If op is not a control object.
    if not op.GetBit(c4d.BIT_CONTROLOBJECT):
        # Yield op if it is derived from one of the passed type symbols.
        if types is None or any([op.IsInstanceOf(t) for t in types]):
            yield op

    # Walk the hierarchy of the cache.
    temp = op.GetDown()
    while temp:
        for obj in CacheIterator(temp, types):
            yield obj
        temp = temp.GetNext()


def main():
    """
    """
    # The user data.
    node = op[c4d.ID_USERDATA, 1]
    angle = op[c4d.ID_USERDATA, 2]
    fieldList = op[c4d.ID_USERDATA, 3]

    # Lazy parameter validation ;)
    if None in (node, angle, fieldList):
        raise AttributeError("Non-existent or non-populated user data.")

    # Get the cache of the node and clone it (so that we have ownership).
    cache = node.GetDeformCache() or node.GetCache()
    if cache is None:
        return c4d.BaseObject(c4d.Onull)
    clone = cache.GetClone(c4d.COPYFLAGS_NONE)

    # Iterate over all bend objects in the cache ...
    for bend in CacheIterator(clone, c4d.Obend):
        # ..., sample the field list for the bend object position, ...
        fieldInput = c4d.modules.mograph.FieldInput([bend.GetMg().off], 1)
        fieldOutput = fieldList.SampleListSimple(op, fieldInput,
                                                 c4d.FIELDSAMPLE_FLAG_VALUE)
        if (not isinstance(fieldOutput, c4d.modules.mograph.FieldOutput) or
                fieldOutput.GetCount() < 1):
            raise RuntimeError("Error sampling field input.")
        # ... and set the bend strength with that field weight as a multiple 
        # of the angle defined in the user data.
        bend[c4d.DEFORMOBJECT_STRENGTH] = angle * fieldOutput.GetValue(0)

    # Return the clone's cache.
    return clone

Hello @shetal,

thank you for reaching out to us. The reformulation of your question and the conformance with the forum guidelines on tagging is also much appreciated.

About your question: As stated in the forum guidelines, we cannot provide full solutions for questions, but provide answers for specific questions. Which is why I will not show here any example code, the first step would have to be made by you. I will instead roughly line out the purpose of and workflow around VideoPostData, which I assume is what you are looking for anyway.

VideoPostData is derived from NodeData, the base class to implement a node for a classic API scene graph. Node means here 'something that lives inside a document and is an addressable entity', examples for such nodes are materials, shaders, objects, tags, ..., and as such 'video post' node. As mentioned in its class description, VideoPostData is a versatile plugin interface which can be used to intervene a rendering process in multiple ways. The most tangible place for VideoPostData in the app is the render settings where video post plugins can be added as effects for a rendering process as shown below with the built-in water mark video post node.

VideoPostData is an effect, meaning that you cannot use it to invoke a rendering process and on its own it also cannot forcibly add itself to a rendering and must be included manually with the RenderData, the render settings of a rendering. However, a user could make a render setting which includes such watermark effect part of his or her default render settings. One could also implement another plugin interface, SceneHookData, to automatically add such effect to every active document. We would not encourage that though, as this could be confusing or infuriating for users. Finally, such VideoPostData plugin would be visible by default like all NodeData plugins, i.e., it would appear as something in menus that the user can add and interact with. To prevent this if desired, one would have to register the plugin with the flag PLUGINFLAG_HIDE suppress it from popping up in the 'Effect ...' button menu. I cannot tell you with certainty if it is possible to hide programmatically added effect nodes from the users view in the effect list of a render settings. There are some flags which can be used to hide instances of nodes, but I would have to test myself if this also applies in this list, it is more likely that this will not be possible.

To implement a VideoPostData plugin interface, one can override multiple methods and take different approaches, the most commonly used one is to override VideoPostData::Execute(Link) which will be called multiple times for each rendered frame. The method follows a flag/message logic which is commonly used in Cinema 4D's classic API, where one gets passed in a flag which signalizes in which context the method is being called. Here the context is at which state of the rendering this call is being made, and the chain is:

• VIDEOPOSTCALL::FRAMESEQUENCE - Series of images starts.
• VIDEOPOSTCALL::FRAME - Image render starts.
• VIDEOPOSTCALL::SUBFRAME - Sub-frame starts.
• VIDEOPOSTCALL::RENDER - Render precalculation.
• VIDEOPOSTCALL::INNER - Render precalculation.
• VIDEOPOSTCALL::INNER - Immediately after rendering.
• VIDEOPOSTCALL::RENDER - Immediately after shader cleanup.
• VIDEOPOSTCALL::SUBFRAME - Sub-frame rendering done.
• VIDEOPOSTCALL::FRAME - Frame rendering done.
• VIDEOPOSTCALL::FRAMESEQUENCE - Complete rendering process finished.

These flags are accompanied by information if the flags denotes the opening or closing of that 'step' in the rendering process. A developer often then restricts its plugin functionality to a certain flag. I.e., in your case you only want to execute some code when the closing VIDEOPOSTCALL::FRAME is being passed, i.e., after a single frame and all its sub-frames have been rendered. Execute() also passes in a pointer to a VideoPostStruct(Link) which carries information about the ongoing rendering. One of its fields is render, a pointer to a Render(Link). This data structure represents a rendering with multiple buffers and provides the method GetBuffer() which returns a pointer to VPBuffer buffer. In your case you would want to retrieve the RGBA buffer for the rendering by requesting the VPBUFFER_RGBA buffer (Link) with GetBuffer().

This buffer is then finally the pixel buffer, the bitmap data you want to modify. The buffer is being read and written in a line wise fashion with VPBuffer::GetLine() and ::SetLine(). Here you would have to superimpose your watermark information onto the frame. I would do this in a shader like fashion, i.e., write a function which I can query for a texture coordinate for every pixel/fragment in every line and it will then return an RBGA value which I could then combine with the RGBA information which is in the buffer at that coordinate. The details on that depend on what you want to do, e.g.,

• Should the watermark be tiled across the frame or just live in a 'corner'?
• Should it contain alpha information?
• Can the user influence it, or is it just a png file on disk?
• etc...

and the answers to that are mostly algorithmic and not directly connected to our API which limits the amount of support we can provide for them. If this all sounds very confusing to you, it might be helpful to look at our video post examples I did post in the previous thread, e.g., vpreconstructimage.cpp, as this will probably make things less daunting.

If you decide that you do not want to take this route for technical or complexity reasons, you could write a SceneHookData plugin which listens via NodeData::Message for MSG_MULTI_RENDERNOTIFICATION(Link), a message family which is being sent in the context of a rendering. There you would have to evaluate the start field in the RenderNotificationData(Link) accompanying the message, to determine if the call is for the start or end of a rendering. Then you could grab the rendering output file(s) on disk with the help of the render settings from disk and 'manually' superimpose your watermark information. This will come with the drawback that you might have to deal with compressed video files like mpeg or Avi and all the image formats. Some complexity in that can be hidden away with our BaseBitmap type I did mention in my last posting, but not all of it. There is also the fact that you might run into problems when this plugin runs on a render server, where you cannot easily obtain write or even read access to files of the render output.

I hope this give you some desired guidance,
Ferdinand

Hey @kng_ito,

Thank you for your reply. I still must do some interpretation here, and your initial core question,

Is there any way to get correct information of key frames on Motion Manager layers?

seems to have been slightly misleading. As you do not seem to want to retrieve the key frames for the layers in your Motion System (e.g., an animation for their strength value), but the key frames of the animation the layer is wrapping. I have changed the title of the topic to better reflect that.

You cannot just iterate over the key frames of the object for that, as they are wrapped by the motion layers. What you see in the in the Timeline Manager is just smoke and mirrors, or more specifically the data from the motion sources. This is evident by the fact that switching the active layer will also change the displayed tracks and curves.

Your Cube object is actually just carrying two tracks with one frame each, which serve as dummies to be dynamically filled by the Motion System when the document is animated. So, this output of yours was correct:

Position . X: 1 Key
Position . Y: 1 Key

Branching and the Motion System

The Motion System is more or less undocumented, even in the C++ API, with no dedicated interfaces for it being publicly provided. But you can access the data you want which is stored in the branches of the Motion System tag. I am not going to expand on the concepts of branches here in all detail, but you can think of them as alternative hierarchy paths. A BaseObject carries a tag branch for all its tags, a document an object branch for all its object, etc. So, instead of just a pure up, down, previous, and next tree, there are things attached to nodes which then contain a hierarchy of their own, the branches.

The data you are looking for is stored in the c4d.NLAbase branches of the Motion System tag controlling the animation.

To find out more about the concept of branches, you can read these two answers of mine on Plugin Café and read the C++ Docs Manual for GeListHead.

1. Simple Branch Traversal (Python): Demonstrates how to traverse a node and all its descendants in all branches and printing them in a makeshift tree. The output shown below has been created with the code from this example.
2. Complex Branch Traversal with Branch Content Mapping (Python): Demonstrates basically the same, only that the code provided here also predicts where it must branch into to find certain kinds of nodes.
3. GeListHead Manual: GeListHead and GeListNode::GetBranchInfo implement the branching logic. This is the C++ Manual for that, but the manual is of questionable quality as it fails to explain the core concept and instead dabbles in technical details.

Accessing the Keyframes of Animations Wrapped by a Motion System

A Motion System tag has an c4d.NLAbase == 5349 branch called 'Motion System'. It contains all the animation layers managed by the system as BaseList2D instances. These are the nodes which are represented by the layer items with sliders in the tag. Each of these layers also has a c4d.NLAbase branch called Animation Layer which holds the 'Motion Sources' for the animation wrapped by the layer. In your case the cube objects on which the original animation has been created. Here you will find the key-frames which are wrapped by the animation layer. To clarify the somewhat wordy explanation, here is a cropped branching tree for the Motion System tag in your scene.

<c4d.BaseTag object called Motion System/Motion System ...          // The Motion System tag.
  Branching into 'Motion System (5349):'                            // Its NLA branch. 
    <c4d.GeListHead>
      Direct Children:'                                             // The nodes inside this branch
        <c4d.BaseList2D object called Layer 0/Motion Layer>         // The first animation layer.
          Branching into 'Animation Layer (5349):'                  // Its NLA branch. 
            <c4d.GeListHead>
              Direct Children:'                                     // The nodes inside this branch.
                <c4d.BaseObject object called Cube/Cube>            // A node holding animation data.
                  Branching into 'Tracks (5350):'                   // Here starts the animation data.
                    ...
        <c4d.BaseList2D object called Layer 1/Motion Layer>         // The second layer.
          Branching into 'Animation Layer (5349):'                  // The same game again ...
            <c4d.GeListHead>
              Direct Children:'
                <c4d.BaseObject object called Cube/Cube>
                  Branching into 'Tracks (5350):'
                    ...

When we put this information together, we can reach into the Motion System data of a Motion System tag to retrieve the nodes which hold the original information, two Ocube objects in your example scene. It is not possible to retrieve the same data from tracks of the Ocube object hosting the Motion System tag, as it is simply not stored there. It is the nodes stored deep inside the tag which drive the animation of the node hosting the animation (and its direct hierarchical descendants).

Find an example which puts all these things together below.

Cheers,
Ferdinand

Result:

The full node graph for <c4d.BaseTag object called Motion System/Motion System with ID 465003000 at 3006362080256>:
----------------------------------------------------------------------------------------------------

<c4d.BaseTag object called Motion System/Motion System with ID 465003000 at 3006362080256>
  Branching into 'Motion System (5349):'
    <c4d.GeListHead object at 0x000002BBF9250DC0>
      Direct Children:'
        <c4d.BaseList2D object called Layer 0/Motion Layer with ID 465003001 at 3006362071744>
          Branching into 'Animation Layer (5349):'
            <c4d.GeListHead object at 0x000002BBF924AF40>
              Direct Children:'
                <c4d.BaseObject object called Cube/Cube with ID 5159 at 3006362212608>
                  Branching into 'Tracks (5350):'
                    <c4d.GeListHead object at 0x000002BBF926CAC0>
                      Direct Children:'
                        <c4d.CTrack object called Position . X/Track with ID 5350 at 3006362078784>
                          Branching into 'Sequences (5351):'
                            <c4d.GeListHead object at 0x000002BBF9244140>
                              Direct Children:'
                                <c4d.CCurve object called  with ID 5351 at 3006362070592>
        <c4d.BaseList2D object called Layer 1/Motion Layer with ID 465003001 at 3006362062912>
          Branching into 'Animation Layer (5349):'
            <c4d.GeListHead object at 0x000002BBF927CE80>
              Direct Children:'
                <c4d.BaseObject object called Cube/Cube with ID 5159 at 3006362173952>
                  Branching into 'Tracks (5350):'
                    <c4d.GeListHead object at 0x000002BBF9273840>
                      Direct Children:'
                        <c4d.CTrack object called Position . Y/Track with ID 5350 at 3006362111168>
                          Branching into 'Sequences (5351):'
                            <c4d.GeListHead object at 0x000002BBF927E700>
                              Direct Children:'
                                <c4d.CCurve object called  with ID 5351 at 3006362199424>
<c4d.BaseTag object called Phong/Phong with ID 5612 at 3006362101184>
----------------------------------------------------------------------------------------------------

Traversing the NLA branches of <c4d.BaseTag object called Motion System/Motion System with ID 465003000 at 3006362080256> for animation data:

<c4d.BaseList2D object called Layer 0/Motion Layer with ID 465003001 at 3006362235840>
<c4d.BaseObject object called Cube/Cube with ID 5159 at 3006362091456>
	Position . X
		Key 0: Value: 0.0, Data: None
		Key 1: Value: 100.0, Data: None
<c4d.BaseList2D object called Layer 1/Motion Layer with ID 465003001 at 3006362238144>
<c4d.BaseObject object called Cube/Cube with ID 5159 at 3006362083840>
	Position . Y
		Key 0: Value: 0.0, Data: None
		Key 1: Value: 34.0, Data: None
		Key 2: Value: 122.0, Data: None

Code:

"""Demonstrates how to unpack animation data stored inside a Motion System tag.

To run this Script Manager script, one must select an object which holds a Motion System tag. It 
will print out all keyframes which are wrapped by the animation layers of the tag. The animation
data data is stored in the #NLAbase branch relations of the tag. 

See https://plugincafe.maxon.net/topic/14298 for a more complete overview of the subject.

Note:
    This example uses two symbols exposed with `2023.0.0`. To run the script in prior versions, one
    must replace them with their integer values or attach attributes of these names and values to
    the c4d module.

    c4d.Tmotionsystem: int = 465003000
    c4d.NLAbase: int = 5349
"""
__version__ = "2023.0.0"

import c4d
import typing

op: typing.Optional[c4d.BaseObject]

def PrintRelatedNodes(node: c4d.GeListNode, indent: int=0):
    """Traverses all node relations of #node and prints them out in a tree-like manner.

    This functions is only used to demonstrate the structure of a motion tag. See 
    https://plugincafe.maxon.net/topic/14056/copy-layershader-to-a-new-material/6 for the original
    and more densely commented code.
    """
    def RepresentNode(node: c4d.GeListNode) -> None:
        """Represents a node over its string representation and branches.
        """
        print(f"{'  ' * indent}{node}")
        if node.GetBranchInfo() == None:
            return

        for item in node.GetBranchInfo():
            branchHead = item["head"]
            name = item["name"]
            tid = item["id"]

            if branchHead.GetDown() == None:
                continue
            
            print (f"{'  ' * (indent + 1)}Branching into '{name} ({tid}):'")
            PrintRelatedNodes(branchHead, indent + 2)

    if not isinstance(node, c4d.GeListNode):
        return

    if indent == 0:
        print (f"{'-' * 100}\n")

    while node:
        RepresentNode(node)
        if node.GetDown():
            print (f"{'  ' * (indent + 1)}Direct Children:'")
            PrintRelatedNodes(node.GetDown(), indent + 2)

        node = node.GetNext()

    if indent == 0:
        print (f"{'-' * 100}\n")

# --- Actual code starts here ----------------------------------------------------------------------

# A type alias for a generator which yields BaseList2D instances.
BaseList2DGenerator: typing.Type = typing.Generator[c4d.BaseList2D, None, None]

def GetMotionData(node: c4d.BaseList2D) -> BaseList2DGenerator:
    """Yields the relevant nodes of a motion system stored in #node by unpacking the branched data.
    """
    def branch(node: c4d.GeListNode, branchTypes: list[int]) -> BaseList2DGenerator:
        """Yields the branches of #node whose ID is contained in #branchTypes.

        Yielded will not be the branch head but the first node in it. Branches with a matching type
        but no nodes will be ignored.
        """
        branchCollection: typing.Optional[list[dict]] = node.GetBranchInfo()
        if branchCollection is None:
            return

        for branch in branchCollection:
            if branch["head"] and branch["id"] in branchTypes and branch["head"].GetDown():
                yield branch["head"].GetDown()

    def iter(node: c4d.GeListNode, branchTypes: list[int]) -> BaseList2DGenerator:
        """Yields the descendants of #node, including its branches and the branches of descendants.
        
        Traversed will only be branches whose ID is contained in #branchTypes.
        """
        if not node:
            return
        
        while (node):
            yield node
            for branchNode in branch(node, branchTypes):
                for child in iter(branchNode, branchTypes):
                    yield child

            for child in node.GetChildren():
                for item in iter(child, branchTypes):
                    yield item
            node = node.GetNext()

    # Iterate over all descendants of #node, branching into all branches that are of type NLAbase.
    # Both motion systems and animation layers live under this branch ID.
    motionTypes: list[int] = [c4d.NLAbase]
    for head in branch(node, motionTypes):
        for node in iter(head, motionTypes):
            yield node

def main() -> None:
    """Runs the example.
    """
    # Check if there is a selected object and that it has a Motion System tag.
    if not op:
        print ("Please select an object.")
        return
    
    tag: c4d.BaseTag = op.GetTag(c4d.Tmotionsystem)
    if not isinstance(tag, c4d.BaseTag):
        print ("Please select an object that has a motion system tag.")
        return

    # To understand what is going on here, we should look at the node data stored in the tag, i.e.,
    # unpack its branches. The tag stores an object for each animation layer it holds under the
    # animation layer branches of its motion system branch.
    print ("The full node graph for {tag}:")
    PrintRelatedNodes(tag)

    # Traverse #tag for the key frames contained within it. When you would have animated the layer
    # strength of the Animation layers, this would also be printed here. Adjust to your liking to
    # retrieve only the data you need.
    print ("Traversing the NLA branches of {tag} for animation data:")
    for node in GetMotionData(tag):
        print (f"Node in an NLA branch: {node}")

        # Iterate over the tracks and curves of the NLA node.
        for track in node.GetCTracks():
            print (f"\t{track.GetName()}")
            curve: c4d.CCurve = track.GetCurve()

            for kid in range(curve.GetKeyCount()):
                key: c4d.CKey = curve.GetKey(kid)
                print(f"Key {kid}: Value: {key.GetValue()}, Data: {key.GetGeData()}")


if __name__ == '__main__':
    main()

Hey @wickedp,

Yeah, that could be the case, there is some weird hacking going on in GeClipMap regarding the bit depth of the managed bitmap and I remember a comment warning about stuff being buggy or slow for the bit depth X (I do not recall the exact number).

But I do not think that this is the case here, I assume you are using .TextAt() and drawing into an empty bitmap canvas. I recognized this before myself too: TextAt() seems to need pixels it can blend into, i.e., you cannot have text over a transparent background. When I stumbled upon this a while ago, I briefly play around with SetDrawMode with little luck and then simply assumed that you cannot have text over a transparent background. I did not dig any deeper then due to lack of time, so my assumption could have been false.

It depends on what you want to do here. If this is just a question out of curiosity, I would leave it at this hint of mine. If you need text over a transparent background, I could have a deeper look, but I will probably only happen next week due to time restrictions and this probably being quite time consuming to find out (GeClipMap is itself only a frontend interface which operates on older and more low-level types).

Cheers,
Ferdinand

Hey @kng_ito,

Thank you for reaching out to us. Could you please provide an example scene file and the code you have written?

Cheers,
Ferdinand

Hey @fwilleke80,

Thank you for reaching out to us. We will talk about this tomorrow in the SDK Group, and Maxime and Manuel might know here more than I do, but one thing jumps to mind here for me:

1. Are you sure there are no build fragments in your build directory, so that the linker/compiler cannot get confused? Visual Studio has sometimes the tendency to make a mess.
2. From which follows, have you stripped the solution from all compilation results? The 'Clean Solution/Build Folder' commands in VS/XCode or unfortunately not very dependable, I would strip the solution by hand or copy over the source files to a new solution.
3. Regenerating/checking your solution could also solve the problem.

Cheers,
Ferdinand

Hello @wickedp,

Thank you for reaching out to us. For GeClipMap::Init(BaseBitmap* bm):

1. Is this copying the bmp into the clip map?
2. Is the clip map now working on the original bitmap?

1. No
2. Yes

This also means that you cannot deallocate the bitmap for the lifetime of the GeClipmap, or more specifically, as long as you intend to call methods on it. This is what is meant by 'the caller owns the pointed bitmap'; it is a polite way of saying 'make sure that this thing stays alive'.

Regarding the casting subject. Inheritance is not always necessary for casting to work, I assume this is where your question came from, and the relevant factor is memory layout. Sometimes we construct types to be layout compliant to other types to allow for casting (without an inheritance relation), the pairs (VPBuffer, MultiPassBitmap) and (Filename, maxon::Url) would be two examples which can be cast without an inheritance relation, for the latter it is however not advisable, you should use MaxonConvert. For GeClipmap this is not true, it just carries a private field for the managed bitmap.

Find below an example which demonstrates the behavior.

Cheers,
Ferdinand

Result (shown is here the first bitmap, i.e., source, it also contains the red square):

source == result = true

Code:

/// @brief Demonstrates the ownership of bitmaps associated with a GeClipMap drawing canvas and the 
/// bitmap object lifetime guarantees a caller must make.
static maxon::Result<void> RunGeClipmapTest(BaseDocument* doc)
{
  // The bitmap we are going to use as a source. We are not using scope based memory management, 
  // AutoAlloc, but handle the bitmap ourselves, to make a point about ownership.
  BaseBitmap* source;
  
  iferr_scope;
  finally
  {
    // Free #source when we exit the function normally or through an error.
    BaseBitmap::Free(source);
  };
  
  // Allocate memory for #source and load an image into it.
  Filename file {"/Users/f_hoppe/Documents/matcopy.gif"_s};
  source = BaseBitmap::Alloc();
  if (!source)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
   
  if (source->Init(file) != IMAGERESULT::OK)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION, "Could not load image file into bitmap."_s);
  
  // Allocate a GeClipMap canvas to draw into and init it with #source, it will copy the pointer
  // and not the object/memory itself.
  AutoAlloc<GeClipMap> canvas;
  if (!canvas)
    return maxon::OutOfMemoryError(MAXON_SOURCE_LOCATION);
  
  if (canvas->Init(source) != IMAGERESULT::OK)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
  
  // Doing something like this will lead to crashes in release mode or stops in debug mode, #canvas
  // relies on the object, the memory region, pointed to by #source for the calls made below.
  // BaseBitmap::Free(source);
  // ---> Thread 1: EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
   
  canvas->BeginDraw();
  canvas->SetColor(255, 0, 0);
  canvas->FillRect(0, 0, 100, 100);
  canvas->EndDraw();
 
  BaseBitmap* const result = canvas->GetBitmap();
  if (!result)
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
  
  // Both source and result will contain the red square in the top left corner because they are the 
  // same object.
  ApplicationOutput("source == result = @"_s, source == result);
  ShowBitmap(source);
  ShowBitmap(result);
  
  return maxon::OK;
}

Hello @bentraje,

Thank you for reaching out to us. Your question is a bit ambiguous, but I largely understand it so that you want to control hair guide vertices programmatically, e.g., bind the vertex of a hair guide to a null object, or even more complex cases as "splines and alembic". The short answer is, no, that is not possible from Python, but it would be from C++.

The longer answer is that while there is c4d.modules.hair in Python, you are effectively restricted to read access. You can write hair guide vertex values, and they will be reflected in a scene in a certain sense, but you lack the means (MSG_HAIR_GET_OBJECT_TYPE) to properly update the hair object using these guides. Which will then result in unrooted hair guides, duplicated guides, and finally crashes. Find an example below.

I will update the Python docs with a warning for others not to run into the same trap I did. What you could however do, is using the Hair Object > Guides > Editing > Points Link parameter to drive the guides. This could be with one of the many deformation tools of Cinema 4D, please reach out to user support for any help with this, or using Python, find a simple example below.

Cheers,
Ferdinand

Hair Module in Python

You should not be doing what I am doing here, as this will lead to crashes.

Scene File: python_hair_crash.c4d

Spline Workaround

Scene File: python_hair_spline_rig.c4d

Result:

Code:

"""Demonstrates how to drive hair guides with a null object.

This could all be done much more elaborately, I implemented here the most simple version possible.
"""

import c4d
import typing

doc: c4d.documents.BaseDocument
op: c4d.BaseTag
bt: typing.Optional[c4d.threading.BaseThread]

ID_SPLINE_OBJECT: int = (c4d.ID_USERDATA, 1)
ID_SPLINE_SEGMENT: int = (c4d.ID_USERDATA, 2)

def GetSegmentVertexIndexRange(spline: c4d.SplineObject, index: int) -> tuple[int, int, int]:
    """Returns the vertex index range for a given segment in a spline.

    Args:
        spline: The spline to evaluate.
        index: The segment index to evaluate.

    Returns:
        The number of vertices in #index,
        The first vertex index in #index,
        The last vertex index in #index
    """
    # Validate the inputs.
    if not isinstance(spline, c4d.SplineObject):
        raise TypeError(f"{spline = }")

    count: int = spline.GetSegmentCount()
    if index > (count - 1):
        raise IndexError(f"Segment index {index} is out of bounds for {spline}.")

    # Get the start and end index by summing up the number of points in all segments up to #index.
    a, b = 0, 0
    for i in range(count):
        if i < index:
            a += spline.GetSegment(i)["cnt"]
            continue
        b = a + spline.GetSegment(i)["cnt"] - 1
        break

    return b - a, a, b

def main() -> None:
    """
    """
    # Get the inputs.
    target: c4d.BaseObject = op.GetMain()
    if not isinstance(target, c4d.BaseObject):
        raise RuntimeError("Tag is not attached to an object.")

    spline: c4d.SplineObject = op[ID_SPLINE_OBJECT]
    if not isinstance(spline, c4d.SplineObject):
        raise TypeError(f"{spline = }")

    # Get the vertex index range for the given segment index, e.g., (0, 8) for the first segment or
    # (9, 17) for the second segment, for a spline with two segments, each holding eight points.
    index: int = op[ID_SPLINE_SEGMENT]
    count, a, b = GetSegmentVertexIndexRange(spline, index)

    # The position of the null object in the coordinate system of the spline object and all its points.
    p: c4d.Vector = ~spline.GetMg() * target.GetMg().off
    points: list[c4d.Vector] = spline.GetAllPoints()

    # The last point q in the segment and the delta vector from q to our target point p.
    q: c4d.Vector = points[b]
    delta: c4d.Vector = p - q

    # Iterate over all points in the segment and adjust their position so that points[b] == p and
    # points[a] == points[a], and all other points cubically interpolated in between.
    for segmentIndex, pointIndex in enumerate(range(a, b + 1)):
        weight: float = (float(segmentIndex) / float(count)) ** 3
        print (segmentIndex, pointIndex, weight)
        points[pointIndex] += (delta * weight)

    spline.SetAllPoints(points)
    spline.Message(c4d.MSG_UPDATE)

Hello @cgweasel,

welcome to the forum and thank you for reaching out to us. I would recommend having a look at our Forum Guidelines as they line out important aspects of the support provided by us here.

What is missing here for my understanding is context, the version you are using, and executable code. Let's start with the simple one.

TypeError: unable to convert builtins.list to @net.maxon.interface.url-C

This means that you are passing something a list (possibly a list of maxon.Url) that expects an argument of type maxon.Url. Or that you did something else incorrectly which causes this error to bubble up somewhere in our wrapper code. Without your code it is not possible to help you more concretely.

I would like a script to collect all my assets in a folder.

Which brings us to the major ambiguity: What do you mean by 'assets' here? There are two asset concepts in the Cinema 4D API. Assests in the classic API sense, as reflected in 'Save Project with Assets', and Maxon Asset API assets, as reflected by the Asset Browser.

There is the idea of the classic API and maxon API in our APIs. Save Project with Assets, c4d.documents.SaveProject(), c4d.documents.GetAllAssetsNew() and the project assets related messages are all classic API concepts. The Asset API, the backend of the Asset Browser, and maxon.Url are both maxon API concepts.

c4d.documents.GetAllAssetsNew() will yield all assets that are used by a scene as a list of dictionaries. You could iterate over them and copy these files to any location you would like to, as long as you have read and write access to the source and destination location. Showing how to copy files with Python is out of scope of support, I cannot do this for you especially when you have provided no code to start with. SaveProject() will save a document with all its assets just as the entry in the file menu. But just as for the file menu command, this will not necessarily reflect Asset Browser assets, when they have not been imported as Xrefs, as they are then just things in your scene, and not assets anymore.

Cheers,
Ferdinand

Hello @a_block,

so I gave it a spin, and the stuff I was thinking of has been removed by Tilo with the recent watch folder updates. We will provide native watch folder support in an upcoming release.

With that being said and knowing that it being provided with 2023.2 or later will throw a wrench into things for you, there are two ways how you can wiggle your way to success here.

1. Simply implement watch folder repositories yourself. It is not that hard, even I can do it The ::RemoveWatchFolder method does not work in my wrapper, don't ask me why. We will have to wait for Maxime's 'proper' version there. But that does not really prevent us from unmounting watch folders, as they are just a database like any other.
2. The other way would be getting creative with relative watch folders associated with a document. When you dig deep enough, you could probably abuse this. But since (1.) is available, why would we want to do this?

Find an example for option one and hints for option two below.

Cheers,
Ferdinand

The result:

asset.GetUrl() = file:///Users/f_hoppe/Documents/plugins/2023/sdk/frameworks/settings/sourceprocessor/pythonsp/macos/lib/python3.9/test/xmltestdata/c14n-20/c14nTrim.xml
asset.GetUrl() = file:///Users/f_hoppe/Documents/plugins/S24/cinema4d_py_sdk_extended-master/scripts/04_3d_concepts/scene_elements/scene_management/basedocument_loops_marker_r17.py
asset.GetUrl() = file:///Users/f_hoppe/Documents/plugins/2023/sdk/frameworks/settings/sourceprocessor/pythonsp/macos/lib/python3.9/test/decimaltestdata/ddInvert.decTest
asset.GetUrl() = file:///Users/f_hoppe/Documents/plugins/2023/sdk/frameworks/settings/sourceprocessor/pythonsp/macos/lib/python3.9/unittest/test/testmock/__init__.py
asset.GetUrl() = file:///Users/f_hoppe/Documents/plugins/2023/sdk/frameworks/settings/sourceprocessor/pythonsp/macos/lib/python3.9/test/cjkencodings/gb18030-utf8.txt
asset.GetUrl() = file:///Users/f_hoppe/Documents/plugins/2023/sdk/build/cinema_hybrid.framework.build/Debug/cinema_hybrid.framework.build/Script-A0C6A0EC1A00000000690000.sh
doc[c4d.DOCUMENT_MOUNTWATCHFOLDER] = 1
doc[c4d.DOCUMENT_RELATIVEWATCHFOLDER] = 'tex'

The code:

"""Provides an example for handling watch folders in Python as of 2023.0.0.

THIS IS A WORKAROUND. We will add the necessary wrappers with an upcoming release, but in the mean
time one could use this as this is close enough to the wrapper Maxime will provide.

I am using here 2023.0.0 API calls, not just for the watch folder stuff. Just pointing this out 
because `asset_watchfolder.h` is technically since S26 around, but was not fully functional then.
"""
__version__ = "2023.0.0"
__copyright__ = "Maxon Computer GmbH"

import os

import c4d
import maxon

#  --- Start of wrapper code -----------------------------------------------------------------------

# Some wrapper stuff.
from maxon.consts import MAXON_REFERENCE_NORMAL
from maxon.interface import MAXON_INTERFACE, MAXON_STATICMETHOD
from maxon.reference import MAXON_REFERENCE

# Wrapping WatchFolderAssetRepositoryInterface
@MAXON_INTERFACE(MAXON_REFERENCE_NORMAL, "net.maxon.interface.watchfolderassetrepository")
class WatchFolderAssetRepositoryInterface(maxon.AssetRepositoryInterface):
    """Represents a repository for a watch folder containing all watched assets.

    This is an AssetRepositoryInterface as any other, you can do all the things with it you can
    do with other AssetRepositoryInterface instances.
    """
    @staticmethod
    @MAXON_STATICMETHOD("net.maxon.interface.watchfolderassetrepository.AddWatchFolder")
    def AddWatchFolder(url: maxon.Url, active: bool) -> None:
        """Adds #url as a watch folder to the running Cinema 4D instance.

        Args:
            url: The url to add.
            active: If True, the repository will be shown in the Asset Browser and contribute
             its assets to the discoverable assets. If #False, the database will only be mounted
             but not activated.
        """
        pass

    @staticmethod
    @MAXON_STATICMETHOD("net.maxon.interface.watchfolderassetrepository.RemoveWatchFolder")
    def RemoveWatchFolder(repo: 'WatchFolderAssetRepositoryRef') -> None:
        """Does not work.
        """
        pass

# Wrapping the Ref for a WatchFolderAssetRepositoryInterface
@MAXON_REFERENCE(WatchFolderAssetRepositoryInterface)
class WatchFolderAssetRepositoryRef(
    WatchFolderAssetRepositoryInterface, maxon.AssetRepositoryRef, maxon.Data):
    """References a `maxon.WatchFolderAssetRepositoryInterface` object.
    """
    def __new__(cls, *args):
        return object.__new__(cls)

# Add both types to the maxon namespace, this is more form than necessity.
maxon.WatchFolderAssetRepositoryInterface = WatchFolderAssetRepositoryInterface
maxon.WatchFolderAssetRepositoryRef = WatchFolderAssetRepositoryRef

# --- End of wrapper code --------------------------------------------------------------------------

def GetWatchFolderRepo(
        url: maxon.Url, forceCreate: bool = False) -> maxon.WatchFolderAssetRepositoryRef:
    """Returns the repository for the given watch folder #url.

    This is a helper function to hide away some boiler plate code on calling ::AddWatchFolder. As
    far as I can see, there are is no helper method for this even in the C++ API.

    Args:
        url: The #url of the repository to retrieve.
        forceCreate: If true, the watch folder will be mounted when not already mounted. Otherwise,
         only an existing repository is retrieved.

    Returns:
        The repository reference for #url.
    """
    # Assert that #url is a URL for a directory.
    if not isinstance(url, maxon.Url):
        raise TypeError(f"{url = }")
    
    # UrlInterface::IoDetect is a more maxonic way to do what I am doing here, but ehhhhhh :)
    sysPath: str = url.GetSystemPath()
    if not os.path.exists(sysPath):
        raise IOError(f"The path '{sysPath}' is not accessible.")
    if not os.path.isdir(sysPath):
        raise IOError(f"The path '{sysPath}' is not a directory.")

    # Mount the watch folder when so indicated, a database cannot be added twice with AddWatchFolder,
    # so no checks are necessary to test if it has already been mounted.
    if forceCreate:
        maxon.WatchFolderAssetRepositoryInterface.AddWatchFolder(url, True)

    # Wait for all databases to load and then try to retrieve the repository for #url.
    if not maxon.AssetDataBasesInterface.WaitForDatabaseLoading():
        raise RuntimeError("Could not load asset databases.")

    obj: maxon.ObjectRef = maxon.AssetDataBasesInterface.FindRepository(url)
    if obj.IsNullValue():
        raise RuntimeError(f"Could not establish repository for: {url}.")

    # #FindRepository returns an ObjectRef, not an AssetRepositoryRef, we must cast it to its "full"
    # form. Specifically, to a reference to a maxon.WatchFolderAssetRepositoryInterface we just 
    # implemented. Yay, casting Python, the dream becomes true :P
    repo: maxon.WatchFolderAssetRepositoryRef = maxon.Cast(maxon.WatchFolderAssetRepositoryRef, obj)
    if repo.IsNullValue():
        raise RuntimeError(f"Could not establish repository for: {url}.")

    return repo

def UnmountDatabase(url: maxon.Url) -> None:
    """Unmounts the database with the given URL.

    .RemoveWatchFolder() does not work in this implementation, don't ask me why. It will be fixed when
    Maxime implements it :P. But removing a watch folder manually is not that hard, since it is just
    a user database.

    You could also do the other things which I showed in the Asset API manuals, e.g., keep the 
    database mounted, but deactivate it.

    Args:
        url: The URL of the database to unmount, could be a watch folder url.
    """
    # Assert that #url is a URL for a directory.
    if not isinstance(url, maxon.Url):
        raise TypeError(f"{url = }")
    
    sysPath: str = url.GetSystemPath()
    if not os.path.exists(sysPath):
        raise IOError(f"The path '{sysPath}' is not accessible.")
    if not os.path.isdir(sysPath):
        raise IOError(f"The path '{sysPath}' is not a directory.")

    if not maxon.AssetDataBasesInterface.WaitForDatabaseLoading():
        raise RuntimeError("Could not load asset databases.")

    # Build the set of all user databases which does not contain the database with the root #url.
    collection: list[maxon.AssetDatabaseStruct] = [
        db for db in maxon.AssetDataBasesInterface.GetDatabases()
        if db._dbUrl != url
    ]

    # And mount this new set, we could also check here if something did actually change to avoid
    # overhead, but I am lazy.
    maxon.AssetDataBasesInterface.SetDatabases(collection)
    if not maxon.AssetDataBasesInterface.WaitForDatabaseLoading():
        raise RuntimeError("Could not load asset databases.")

doc: c4d.documents.BaseDocument
    
def main():
    """Runs the example.
    """
    # The folder to mount, you should obviously provide here a path of your own.
    url: maxon.UrlInterface = maxon.Url(r"/Users/f_hoppe/Documents/plugins")

    # Add the repository for a watch folder at #url, we use here our little helper function to hide
    # away a bit of boiler plate code.
    repo: maxon.WatchFolderAssetRepositoryRef = GetWatchFolderRepo(url, forceCreate=True)
    if not repo:
        raise RuntimeError(f"Could not establish watch folder for: {url}")

    # Find all assets in #repo, see the Asset API examples for more elaborate search operations. As
    # always, all assets of #repo will also be contained in the user prefs repo.
    assetCollection: list[maxon.AssetDescriptionInterface] = []
    repo.FindAssets(maxon.Id(), maxon.Id(), maxon.Id(), maxon.ASSET_FIND_MODE.LATEST, assetCollection)

    # Iterate over the first five or less assets in #repo.
    for asset in assetCollection[:6]:
        print (f"{asset.GetUrl() = }")

    # And remove the database again.
    # UnmountDatabase(url)

    # --- Some BaseDocument shenanigans ------------------------------------------------------------

    # I did not flesh this one out, as it is very hack and probably not a good idea. These are the
    # settings of the watch folders associated with a document. By default this is just the common
    # Cinema 4D 'tex' folder, but I think you can have more than one of them. There is also stuff
    # in the world prefs. You would have to poke around a bit here and there, but I would not
    # recommend doing so.

    print (f"{doc[c4d.DOCUMENT_MOUNTWATCHFOLDER] = }")
    print (f"{doc[c4d.DOCUMENT_RELATIVEWATCHFOLDER] = }")


if __name__ == "__main__":
    main()

Hello @lawzy,

Can you help in this part please? That would help a lot! Thanks again.

Broadly speaking, the answer is no, because we are not in the habit of writing solutions for users. Sometimes we make an exception, as I did here for you. But please understand that you must learn how to implement things yourself.

I think it goes something like this.. But I have no idea how to proceed.

    if BatchRender.IsRendering() == True ...

Yes, that is roughly what you must do. You have to wrap this however into a loop as you are here only polling the renderer once if it is still running. You must instead poll until it is not running anymore. So, something like this:

while batchRender.IsRendering():
    # The renderer is still rendering.
    pass
# When this line is reached, the renderer has finished.

But there are also other hoops to jump through. I provided a draft for how you could implement this below.

Cheers,
Ferdinand

"""Demonstrates the to launch a render using the batch renderer and wait for it finish before
carrying out another task.
"""
import c4d
import typing
import os
import re
import time

from c4d.documents import BaseDocument, BatchRender, RenderData

doc: BaseDocument # The active document.

def RunBatchRenderJob(doc: BaseDocument) -> tuple[str, str]:
    """Renders the passed document with the render queue.

    Returns the output path and file name pattern as defined in the render settings of the document.
    This function is blocking, i.e., while it is rendering, you will not be able to interact with
    Cinema 4D. This could be changed, but doing this would be up to you.

    Args:
        doc: The document to render.

    Raises:
        RuntimeError: On invalid arguments and failure to operate the render queue.

    Returns:
        The tuple (output directory, render_filename_pattern).
    """
    # Get out when #doc is not a document, has not been saved yet, or the batch renderer is already
    # running. You could also stop an ongoing rendering but I did not.
    if not isinstance(doc, BaseDocument) or doc.GetDocumentPath() == "":
        raise RuntimeError(f"Invalid document: {doc}")

    batchRender: BatchRender = c4d.documents.GetBatchRender()
    if batchRender.IsRendering():
        raise RuntimeError(f"Batch renderer is running.")

    # Disable all render jobs which are at the moment in the queue.
    for i in range(batchRender.GetElementCount()):
        batchRender.EnableElement(i, False)

    # Get the path of the passed document file and render output path from the active render settings
    # of the document.
    filePath: str = os.path.join(doc.GetDocumentPath(), doc.GetDocumentName())
    rdata: RenderData = doc.GetActiveRenderData()
    renderPath: str = rdata[c4d.RDATA_PATH]

    # A render path can come in three forms and we must figure out where the absolute path
    # of the renders is without the file name with tokens.
    #
    #   1. An absolute path, e.g., c:\blah\blah\myRender_#camera_
    #   2. A path relative to the document, e.g., output\myRender_#camera_
    #   3. A file name to the document, e.g., myRender_#camera_

    # Split the path and file name component of #renderPath, and make the renderPath absolute in
    # relation to the document.
    renderPath, renderName = os.path.split(renderPath)
    if not os.path.isabs(renderPath):
        renderPath = os.path.normpath(os.path.join(doc.GetDocumentPath(), renderPath))

    # Add the job at the top, turn on the spin-indicator in the status bar, and start the rendering.
    if not batchRender.AddFile(filePath, 0):
        raise RuntimeError(f"Could not add render job for file: {filePath}")
    
    c4d.StatusSetSpin()
    batchRender.SetRendering(c4d.BR_START)

    # Wait for the render to finish, this a blocking way to implement it, i.e., you will not be
    # able to interact with Cinema 4D until the render has finished. There are more fancy ways to
    # do this with threads which are not blocking, but doing this would be up to you. We wait for a
    # second so that we do not bombard the renderer with IsRendering() polling.
    while batchRender.IsRendering():
        time.sleep(1)

    # The rendering is done, clear the status bar and return the output path and filename pattern.
    c4d.StatusClear()
    return renderPath, renderName

def RenameFiles(path: str, namePattern: str) -> None:
    """Renames files #path by stripping away the frame counter postfix.

    This could be done much more elaborately using the #namePattern argument. I did not do this here.

    Args:
        path: The path to inspect and rename files in. No recursion will happen, i.e., only files
         in #path will be renamed, not files in #path/foo/ for example.
        namePattern: The file name as defined in the render settings of the document, e.g., 
         foo_#frame_1234. Not used here.
    """
    if not os.path.exists(path):
        raise RuntimeError(f"'{path}' does not exist.")
    
    # A regular expression to match three or four digit frame counter at the end of a file name.
    pattern: re.Pattern = re.compile(r"\d\d\d\d?$")

    # Iterate over all files in #path and rename them.
    for oldName in os.listdir(path):
        oldPath: str = os.path.join(path, oldName)
        if not os.path.isfile(oldPath):
            continue
        
        # Split the file name and extension and test if the file name matches #pattern.
        name, extension = os.path.splitext(oldName)
        if not pattern.search(name):
            continue
        
        # Strip away the frame counter part of the name and build a new full file path.
        newName: str = pattern.sub("", name) + extension
        newPath: str = os.path.join(path, newName)

        # Rename the file or raise an error when lack access rights or such file does already exist.
        try:
            os.rename(oldPath, newPath)
        except Exception as error:
            print (f"Stepping over file access error: {error}")

        print (f"Renamed '{oldName}' to '{newName}'.")

def main():
    """Runs the example.
    """
    result: tuple[str, str] = RunBatchRenderJob(doc)
    RenameFiles(*result)


if __name__ == "__main__":
    main()

I reached out to you via mail, to discuss the licensing subject in a more private setting. The mail was sent to the email handle your account here on Plugin Café is bound to.

Cheers,
Ferdinand