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

Hello @chuanzhen,

Thank you for reaching out to us. Your question is a little bit ambiguous as you do not clearly state what this message function of yours is a member of.

As explained in the Message System Manual, there are multiple types of message methods. Important in your specific use case is that there are two method 'groups' which have the general signature Message(a: int, b: typing.Any) -> bool, one attached to C4DAtom and one attached to GeDialog, GeUserArea and CommandData. There is a slight difference in their argument naming convention, but argument names do not carry any meaning here:

C4DAtom.Message(self, type, data=None) # This is a node message method.
NodeData.Message(self, node, type, data) # This is the node plugin hook counter part of it.

CommandData/GeDialog/GeUserArea.Message(self, msg, result) # This is a GUI/CommandData message method.

So, from the context - you said "I want to refresh the dialog" - I would assume you are implementing a GeDialog or CommandData and have there the code snippet you posted. Using the argument naming convention of C4DAtom.Message will do not any direct harm except for confusing an experienced C4D API reader, but you must understand that these are different methods which are called for different sets of events (i.e., message IDs). A GeDialog.Message will not be called for node events and a C4DAtom.Message will not be called for GUI events.

• MSG_DOCUMENTINFO is a node message sent to node instances, you will not receive it in dialogs.
• MSG_COMMANDINFORMATION is a plugin message sent to CommandData plugins.

Inside a CommandData or GeDialog there is no dedicated message you can listen to for being notified about document changes (the whole MSG_DOCUMENTINFO message family is not being broadcasted to these methods). You must keep track of the active document yourself.

I have shown here what would be good pattern to implement such thing, at the slightly more complex case of tracking objects. The principal algorithm would be:

1. Overwrite GeDialog.CoreMessage.
2. On a EVMSG_CHANGE event, get the active document.
3. Get the MAXON_CREATOR_ID of the document to identify the document (documents are also nodes, so you can just call myDoc.FindUniqueID(c4d.MAXON_CREATOR_ID) on your document).
4. Compare the unique id against a lookup value MyDialog._activeDocUuid.
5. When the comparison in 4. fails, the document has changed.
6. Store that UUID hash from 3. as the new MyDialog._activeDocUuid.

You must take this route over UUIDs, as nodes can be reallocated and destroyed, and you will then encounter false positives when you just store a BaseDocument in the lookup _activeDocUuid instead of its MAXON_CREATOR_ID hash. As shown in the lights example linked above, there are multiple levels of complexity you can implement this with, and for example implement _activeDocUuid as a list or hash map which tracks more than one thing.

I hope this helps and cheers,
Ferdinand

Hello @dunhou,

Thank you for reaching out to us. As already pointed out by @x_nerve, your question is unfortunately out of scope of support as stated by our forum guidelines:

• We cannot provided support for third party libraries or code design that is in direct violation of Cinema's technical requirements (e.g. Cinema 4D's threading restrictions).

• We cannot provide support for learning either C++, Python, or one of its popular third-party libraries.

You are however more than welcome to seek help from other users here. But the problem is also that translating the code does not make too much sense, because it is littered with things that are not part of our Python API. If OTOY also does provide a Python API for their renderer, then this might be mitigated by it. Find below a translation which exemplifies this by marking missing elements as ???.

I would recommend reaching out to OTOY, as we cannot provide any support for this.

Cheers,
Ferdinand

C++:

BaseList2D *addAOVnode(BaseList2D *parent, Int32 slotID, Int32 TYPE, Octane::RenderPassId passId, Bool incCnt)
{
   BaseContainer *bc = parent->GetDataInstance();
   Int32 pType = bc->GetInt32(AOV_NODE_TYPE);

   BaseList2D *shd = addOctaneShaderToNode(parent, slotID, ID_OCTANE_AOV_NODE);

   if(TYPE==AOV_TYPE_COMP_GROUP)       {  shd->SetName(AOV_GROUP_NAME);  }
   else if(TYPE==AOV_TYPE_COMP_AOV)         {  shd->SetName(AOV_COMP_NAME);  }
   else if(TYPE==AOV_TYPE_COMP_AOV_LAYER)   {  shd->SetName(AOV_COMPLAYER_NAME);  }
   else if(TYPE==AOV_TYPE_COLOR_OUT)        {  shd->SetName(AOV_COLOROUT_NAME);  }
   else if(TYPE==AOV_TYPE_IMAGE_AOV_OUT)    {  shd->SetName(AOV_IMAGEOUT_NAME);  }
   else if(TYPE==AOV_TYPE_COMP_LIGHTMIXER)  {  shd->SetName(AOV_IMAGEOUT_NAME);  }
   else if(TYPE==AOV_TYPE_RENDER_AOV_OUT)
   {
       shd->SetParameter(DescLevel(AOV_RENDER_PASS_ID), GeData((Int32)passId), DESCFLAGS_SET_0);
       shd->SetName(AOV_RENDEROUT_NAME+S(":[")+ rPassName(passId)+"]");
   }

   setParameterLong(*shd, AOV_NODE_TYPE, TYPE);
   if(incCnt)
   {
       Int32 cnt = bc->GetInt32(AOV_INPUT_COUNT);
       setParameterLong(*parent, AOV_INPUT_COUNT, cnt+1);
   }
   return shd;
}

--- snip -------------------------------------------------------------------------------------------
Python approximation:

AddAOVnode(parent: c4d.BaseList2D, slotID: int, TYPE: int, passId: ???, incCnt: bool) -> c4d.BaseList2D:
   """
   """
   bc: c4d.BaseContainer = parent.GetDataInstance()
   pType: int = bc[???]

   shd: c4d.BaseList2D = ???(parent, slotID, ???)

   if TYPE == ???:
      shd.SetName(???)
   ...
   elif TYPE == ???:
       shd.SetParameter(???, passId, DESCFLAGS_SET_NONE)
       shd.SetName(f"{???}[{???(passId)}]")

   ???(shd, ???, TYPE)
   if incCnt:
       cnt: int = bc.GetInt32(???)
       ???(parent, ???, cnt + 1)

   return shd

Hello @rui_mac,

ah, okay, I understand what you mean. Yeah, that is a bit odd and also makes this solution not very viable. As I said before, this always was a hack. When I did this myself a few years ago, I think I never ran into this issue.

The underlying problem here is that the Attribute Manager is able to display a hidden tag as selected and the whole setup relies on the fact that hidden tags are being ignored in that context. It is also very erratic how this happens, when I for example click long enough on the Draw Data bool, the problem will also occur at some point and at the same time, it sometimes it does not happen 'inside' the vertexmap when I change a parameter there.

Since this seems to be tied to parameter writing events, you could try to switch off the hidden tag being selected before a parameter is being written and turn it back on after that. But that will become really complicated or even possible to do for 'buried' parameters changes, such as for example, changing something in a field driving a vertex map which is linked in the tag.

I will file this as a bug because the Attribute Manager should not be able to display hidden tags in single or multi-selections. In the meantime, I can only recommend using C++ and drawing things yourself or using CustomDataTagDisplayInterface, as this will be performant and is also guaranteed to work.

Cheers,
Ferdinand

Hello @spedler,

Thank you for reaching out to us. No, this is unfortunately not yet officially supported. There will be a Redshift API at some point, but we will still need a bit more time for that.

There is a way to do it, but all I can do here is giving you the hint that you must get hold of the C4DOS pointer and call a function of it. Look at operatingsystem.h (the actual file, not its documentation), there you can figure out how it works. And for future readers: No, I unfortunately cannot clarify this. The public API is public, but I cannot disclose how to 'hack' it (its not that hard to do but you must take the leap ypurself).

I understand that this answer is cryptic and unsatisfying, but it is the best I can do for now, my apologies.

Cheers,
Ferdinand

Dear Cinema 4D Community,

On September the 7th, 2022, Maxon Computer released Cinema 4D 2023.0.0. Alongside this release, a new Cinema 4D SDK and SDK documentation have been released, reflecting the API changes for 2023.0.0.

The major changes in this documentation update are in C++ exposure of OCIO interfaces and the added legacy plugin type symbols. In Python, minor bug fixes have been carried out and an updated version of the VS Code plugin for Cinema 4D 2023.0.0 has been provided. Please refer to the Maxon One Fall Update notes for details on the changes of the application itself.

To see the latest version of the C++ SDK Online Documentation and Python SDK Online Documentation you must still refresh your browser cache by pressing CTRL + F5 once one the landing page. We have decided for now not to remove the caching.

Happy rendering and coding,
the Maxon SDK Team

Hello @rui_mac,

So, I had a look at your code. It was unfortunately not executable in this form, even when I filled in some gaps like adding the necessary resources or re-indenting stuff. So, I cannot say many concrete things here, and only look at the general form.

I must also point out again, that this is a hack and not officially supported. If you chose to take this route instead of drawing the data yourself, possible side effects will be up to you to handle.

• A general thing is that you seem to assume that Message, Init, and other methods to always run on the main thread. But there is no guarantee for that; when you want to carry out actions only allowed on the main thread, you must still check for being on the main thread. I however still think that adding a tag from a non-main thread was not your issue here.
• This line in your Init is dangerous and might be the source for your problems, as you forcibly select the host object of your tag: op.SetBit(c4d.BIT_ACTIVE)
• In general, you are also very generous with Message(c4d.MSG_UPDATE) calls. They are first of all here unnecessary for the flag changes and secondly also dangerous. I would never send messages to a node which is already part of the scene graph from threaded environment (you call op.Message(c4d.MSG_UPDATE) in multiple contexts).
• Using the name of a node is a poor way of identifying a node, you should use UUIDs in Python.
• I have provided below a TagData solution for your problem. This is quite a bit of busy work, especially when you want to properly clean up after yourself. This works fine for me.

if it would be possible to make the VertexMap shading appear, simply by using this visible VertexMap tag, I would be more than fine with this.

It would be the same, just iterate over the tags of the node hosting your tag and select whatever tags you want to select.

Cheers,
Ferdinand

The result:

The plugin: pc14184.zip

The pyp file of the plugin:

"""Implements a tag which manages a hidden vertex map to draw data.
"""
import c4d
import typing

class VertexMapMixData(c4d.plugins.TagData):
    """Implements a tag which manages a hidden vertex map to draw data.
    """
    PLUGIN_ID: int = 1037312
    DRAWTAG_ID: int = 1060040

    PLUGIN_NAME: str = "VertexMapMix"
    PLUGIN_DESCRIPTION: str = "Tvertexmapmix"

    def __init__(self) -> None:
        """Initializes the instance, specifically its _hiddenDrawTags lookup table.
        """
        self._hiddenDrawTags: dict[bytes: c4d.BaseTag] = {}
        super().__init__()

    def FlushHiddenTags(self, node: c4d.GeListNode) -> None:
        """Flushes the #_hiddenDrawTags cache and removes all the hidden tags from the hosting node.
        """
        host: typing.Optional[c4d.BaseObject] = node.GetMain()
        if not isinstance(host, c4d.BaseObject):
            return

        tag: c4d.BaseTag
        for tag in host.GetTags():
            if tag.GetType() != c4d.Tvertexmap:
                continue

            # This is a hidden drawing tag instance.
            uuid: typing.Optional[memoryview] = tag.FindUniqueID(VertexMapMixData.DRAWTAG_ID)
            if isinstance(uuid, memoryview):
                tag.Remove()

        self._hiddenDrawTags = {}

    def GetHiddenDrawTag(self, node: c4d.PolygonObject) -> typing.Optional[c4d.VariableTag]:
        """Retrieves the hidden drawing tag on a polygon object.
        """
        # Bail when #node is not a polygon object or not attached to a document.
        if (not isinstance(node, c4d.PolygonObject) or
                not isinstance(node.GetDocument(), c4d.documents.BaseDocument)):
            return None

        # Get the UUID of the polygon object so that we look up its hidden tag in the lookup.
        uuid: typing.Optional[memoryview] = node.FindUniqueID(c4d.MAXON_CREATOR_ID)
        if not isinstance(uuid, memoryview):
            return None

        # Check if there is already a cached hidden draw tag in dictionary of the plugin interface.
        hiddenTag: typing.Optional[c4d.BaseTag] = self._hiddenDrawTags.get(bytes(uuid), None)
        if isinstance(hiddenTag, c4d.BaseTag) and hiddenTag.IsAlive():
            return hiddenTag

        # Just for verbosity here to make clear that this can still return None.
        return None

    def SetHiddenDrawTag(self, node: c4d.BaseTag) -> None:
        """Creates the hidden drawing tag on a polygon object.
        """
        # The host is not a polygon object or there is already a valid drawing tag on that host.
        if (not isinstance(node, c4d.PolygonObject) or
                isinstance(self.GetHiddenDrawTag(node), c4d.VariableTag)):
            return

        # Flush the cache to remove any lingering tags and get the UUID of the polygon object so
        # that we cache the hidden draw tags.
        self.FlushHiddenTags(node)
        hostUuid: typing.Optional[memoryview] = node.FindUniqueID(c4d.MAXON_CREATOR_ID)
        if not isinstance(hostUuid, memoryview):
            return

        # Start creating the new tag, for that we must be on the main thread.
        if not c4d.threading.GeIsMainThread():
            return

        tag: c4d.VariableTag = c4d.VariableTag(c4d.Tvertexmap, node.GetPointCount())
        if not isinstance(tag, c4d.BaseTag):
            raise MemoryError("Could not allocate vertex map tag.")

        tag.AddUniqueID(VertexMapMixData.DRAWTAG_ID, bytes(True))
        tag.ChangeNBit(c4d.NBIT_OHIDE, True)
        node.InsertTag(tag)

        # Put the tag in the lookup table.
        self._hiddenDrawTags[bytes(hostUuid)] = tag

    def Init(self, node: c4d.GeListNode) -> bool:
        """Called by Cinema 4D to initialize the node.
        """
        self.InitAttr(node, c4d.BaseList2D, c4d.ID_SOURCE_DATA)
        self.InitAttr(node, bool, c4d.ID_DRAW_DATA)

        node[c4d.ID_SOURCE_DATA] = None
        node[c4d.ID_DRAW_DATA] = True

        # Attempt to create the tag, as all methods, Init is not guaranteed to be on the main thread.
        self.SetHiddenDrawTag(node.GetMain())
        return True

    def Free(self, node: c4d.GeListNode) -> None:
        """Called by Cinema 4D when the node is about to be destroyed.

        Will remove all hidden tags on the node.
        """
        self.FlushHiddenTags(node)

    def CopyTo(self, dest: c4d.plugins.NodeData, snode: c4d.GeListNode, dnode: c4d.GeListNode,
               flags: int, trn: c4d.AliasTrans) -> bool:
        """Called by Cinema 4D when a tag is being copied.

        Will remove all hidden tags on the source node, so that when a user drag-and_drops the tag 
        from object A to object B, object A is being cleaned up.
        """
        self.FlushHiddenTags(snode)
        return True

    def Message(self, node: c4d.GeListNode, type: int, data: object) -> bool:
        """Called by Cinema 4D to send messages to the node.

        We just use this here as something that is called often on the main thread. But there is
        no guarantee that this will run on the main thread, you were sending yourself a message, 
        MSG_UPDATE, to a node outside of the main thread in your TagData::Execute. Never assume
        Message to run on the main thread only.
        """
        # Try to create the tag, could be throttled by picking a specific message ID which is
        # called often enough.
        self.SetHiddenDrawTag(node.GetMain())
        return True

    def Execute(self, tag: c4d.BaseTag, doc: c4d.documents.BaseDocument, op: c4d.BaseObject,
                bt: c4d.threading.BaseThread, priority: int, flags: int) -> int:
        """Called by Cinema 4D to execute the tag.
        """
        state: bool = tag[c4d.ID_DRAW_DATA]
        src: typing.Optional[c4d.VariableTag] = tag[c4d.ID_SOURCE_DATA]
        dst: typing.Optional[c4d.VariableTag] = self.GetHiddenDrawTag(op)

        # There is no source or destination tag we could write from or to.
        if not isinstance(src, c4d.VariableTag) or not isinstance(dst, c4d.VariableTag):
            return c4d.EXECUTIONRESULT_OK

        # Select or deselect the hidden tag.
        if tag[c4d.ID_DRAW_DATA]:
            dst.SetBit(c4d.BIT_ACTIVE)
        else:
            dst.DelBit(c4d.BIT_ACTIVE)

        # Determine of we should copy the data and then copy the data.
        if (src.GetType() != dst.GetType() or
                src.GetDataCount() != dst.GetDataCount()):
            return c4d.EXECUTIONRESULT_OK
        dst.SetAllHighlevelData(src.GetAllHighlevelData())

        return c4d.EXECUTIONRESULT_OK


def RegisterPlugin() -> None:
    """Registers the plugin.
    """
    if not c4d.plugins.RegisterTagPlugin(
            id=VertexMapMixData.PLUGIN_ID,
            str=VertexMapMixData.PLUGIN_NAME,
            g=VertexMapMixData,
            description=VertexMapMixData.PLUGIN_DESCRIPTION,
            icon=c4d.bitmaps.InitResourceBitmap(c4d.FLgradient),
            info=c4d.TAG_EXPRESSION | c4d.TAG_VISIBLE | c4d.TAG_MULTIPLE):
        raise RuntimeError(f"Failed to register: {VertexMapMixData}")


if __name__ == "__main__":
    RegisterPlugin()

Hello @dunhou,

thank you for reaching out to us. Thank you for the detailed report, a little tip though, when you provide error outputs (either as text dumps or as screenshots), or when you want to debug yourself, you should always make sure the script has been saved first. As only for a saved script you will get a stack trace which contains the actual line of code which failed (and not just its line number). Due to formatting errors, line numbers can be a bit ambiguous on the forum.

E.g., when you run the script without an object selected and without the script being saved, it will spit out the following because op is then None.

Traceback (most recent call last):
  File "scriptmanager", line 44, in <module>
  File "scriptmanager", line 30, in main
AttributeError: 'NoneType' object has no attribute 'GetData'

When you do the same with a saved script the stack trace will be:

Traceback (most recent call last):
  File "C:\Users\f_hoppe\AppData\Roaming\Maxon\2023.0.0_C4F8B542\library\scripts\untitled 2.py", line 44, in <module>
    main()
  File "C:\Users\f_hoppe\AppData\Roaming\Maxon\2023.0.0_C4F8B542\library\scripts\untitled 2.py", line 30, in main
    fieldlists = [value for id, value in op.GetData()
AttributeError: 'NoneType' object has no attribute 'GetData'
>>> 

Which is quite a bit more informative, as you can see the actual line of code which failed.

About your Issue

From the context of things, I would assume it is doc.AddUndo(c4d.UNDOTYPE_CHANGE,obj) which is failing in your code because obj is None. The method FieldLayer.GetLinkedObject can return None because not all FieldLayer have a BaseObject representation. Or less technical: Not for every entry in a field list necessarily a matching object in the Object Manager can be found.

When I run your script on 'logical' inputs, i.e., an object with a field list containing a field list which only contains layers which each have an object, the script works fine for me. The problem only occurs when I add such 'unrepresented' layer type, e.g., a solid layer. So, you must simply check obj for being None or check the type of the field layer first before you try to get its linked object.

In case this does not solve the problem for you, I would have to ask you to share the scene/object on which you are running the script, because the setup of the field list matters here.

Cheers,
Ferdinand

Hello @chuanzhen,

thank you for your patience. The relevant symbol is RDATA_GLOBALSAVE, i.e., toggling this boolean will check or uncheck the checkbox before the Save item in the video post list on the left in the Render Settings.

As a general hint, you can find all c4d.documents.RenderData symbols which are not part of a separate video post plugin in our Python SDK documentation. I just went there and highlighted all instances of the word 'save' and then looked for a Boolean with a promising description. But this is just a special case, usually you are faster with the drag and drop approach described in the posting I have linked in my first answer here.

Cheers,
Ferdinand

Hello @rui_mac,

I will have a look tomorrow; I was busy today.

Cheers,
Ferdinand

Hey @chuanzhen,

I have not overlooked your addition here, but I was a bit busy, will be the next thing on my desk tomorrow.

Cheers,
Ferdinand