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 @C4DS and @Motion4D,

thanks you two, that is very kind of you. A happy new year to you too and everyone in the forum.

Cheers,
Ferdinand

Hi,

I cannot reproduce this neither. The interesting question would be what does print random.seed for you and is this reproduceable on your end?

My suspicion would be that someone or something treated random.seed() like a property instead of like a function, which then led to - with all the "Python functions are first class objects" thing - random.seed being an integer. Something like this:

>>> import random
>>> print(random.seed)
<bound method Random.seed of <random.Random object at 0x103b62218>>
>>> random.seed(12345)
>>> random.seed = 12345 # 'accidently' treating it like a property
>>> print(random.seed)
12345
>>> random.seed(12345)
Traceback (most recent call last):
  File "<string>", line 1, in <module>
TypeError: 'int' object is not callable

Cheers
zipit

Hello @JH23,

thank you for reaching out to us. While it is possible to use CallCommand in scripts for the more basic things like creating a material, it is recommended to use the more abstract object-oriented API whenever possible. Below you will find an example script which creates, modifies and assigns a new material to the currently active object.

Cheers,
Ferdinand

"""Example for creating a material and assigning it to the currently active 
object.

As discussed in:
    https://plugincafe.maxon.net/topic/13357
"""

import c4d

def main():
    """
    """
    # op and doc a are module attributes predefined by Cinema 4D for a script 
    # module. doc is the currently active document, op the currently active 
    # object in this active document.
    if op is None:
        raise RuntimeError("Please select an object.")
    
    # Instantiate a standard material and insert it into the document, as 
    # otherwise we could not use it.
    mat = c4d.BaseList2D(c4d.Mmaterial)
    doc.InsertMaterial(mat)
    # Example for modifying the material, here setting its diffuse color.
    mat[c4d.MATERIAL_COLOR_COLOR] = c4d.Vector(1, 0, 0)

    # Create a texture tag on the selected object, change the projection mode
    # to uvw and link the newly crated material to it.
    tag = op.MakeTag(c4d.Ttexture)
    tag[c4d.TEXTURETAG_PROJECTION] = c4d.TEXTURETAG_PROJECTION_UVW
    tag[c4d.TEXTURETAG_MATERIAL] = mat

    # Notify Cinema 4D of the changes made.
    c4d.EventAdd()

# Execute main()
if __name__=='__main__':
    main()

Hello @kbar,

if you need further information, please feel free to unflag this topic. But as you know, we have a fourteen-days radio silence policy for closing topics. We understand that this can collide with workloads in a production environment, but we have to apply some form of control here. Which we feel is rather generous, since you can push back a topic almost indefinitely by simply posting in it.

Thank you for your understanding,
Ferdinand

Hello Frank,

we will answer this more thoroughly tomorrow, but the trick when providing a vertex color map in a cache, is to select it, as this is the condition for Cinema to draw it. For your "moved goal posts" of having a shader/material, this can become tricky, because as providing materials is not an intended functionality for generator caches. But you probably know that.

The common workaround is then to assign the material to the generator and not the cache and hide the material as you already said yourself. But when you are going to rely on vertex colors, you are going to have a problem, I think. The problem is that you cannot assign the vertex color tag to the generator, as this won't work. Vertex color tags seem to be unable to reach into caches, I just tried. So, you will have to keep the vertex color tag on the cache. You can then still create just your material with a vertex map shader in it to do all your fancy shading and assign it to the generator (and hide it). The problem is: The vertex color shader would then have to reach/link into the cache to get the tag from there. Which I think should work in principal, have not tried myself though, but is obviously the definition of "dicey".

Cheers,
Ferdinand

PS: This is a "private" answer of mine, just because I thought it is an interesting problem ^^

import c4d
import random

def CreateVertexColors(node):
    """
    """
    # Pretty straight forward per vertex definition of vertex colors.
    count = node.GetPointCount()
    tag = c4d.VertexColorTag(count)
    tag.SetPerPointMode(True)
    data = tag.GetDataAddressW()

    for pid in range(count):
        color = c4d.Vector4d(random.uniform(0., 1.),
                             random.uniform(0., 1.),
                             random.uniform(0., 1.), 1.)
        c4d.VertexColorTag.SetPoint(data, None, None, pid, color)

    # Add the tag and the magic bit, quite literately, select it.
    node.InsertTag(tag)
    tag.SetBit(c4d.BIT_ACTIVE)

def main():
    """
    """
    # Get our cache source, cause I was to lazy to come up with some geom. :)
    source = op[c4d.ID_USERDATA, 1]
    if not isinstance(source, c4d.PolygonObject):
        return c4d.BaseObject(c4d.Onull)

    # Clone the cache source and create a vertex color map for it.
    cache = source.GetClone(0)
    cache.SetMg(c4d.Matrix())
    CreateVertexColors(cache)

    return cache

Hello @codysorgenfrey,

thank you for reaching out to us. Your question is a bit hard to answer, given the abstract nature of the provided code and the absence of a specific setup/file. I would however point out that:

1. This number of revisions expressed as a vector, i.e., separated onto axis, strikes me as a bit odd, since this is not how rotation works ^^
2. Using BaseObject.GetMl() can make things harder to compute, depending on your setup. I would stay in world space.
3. Most importantly I would point that you do not seem to take order of rotation into account, i.e., that matrix multiplication is not commutative, i.e., M * N != N * M which might get in the way in your second to last line, as you do not make this dependent on the travel direction.

I personally would also take a more "transform" oriented approach. As it much easier to just rotate a vector than figuring out into which direction you are now traveling and what that means for constructing a transform in "the proper way". I have provided below a quick solution as Python scripting tag, which is more meant to line out the approach rather than being a full solution (which we cannot provide). My solution requires an "aligned-with-world-frame" orientation for the start of travel. It would not be too hard to fix this, you must account for that additional delta before applying the final transform. I am just running a bit of time here, especially since this question is a bit out of scope of support (as it is just a math question).

If you need further help, also with the "alignment" condition, just ask

Cheers,
Ferdinand

The result:

The file: rot_cube.c4d

The code:

import c4d
import math

# Global non-static variables are a really bad idea. Please replace this
# in a production environment with a more safe approach by for example
# storing this as a user-data parameter or just as an element in a
# BaseContainer of a node.
PREVIOUS_POSITION = None

NULL_VECTOR = c4d.Vector()
UP_VECTOR = c4d.Vector(0, 1, 0)

def main():
    """
    """
    # Get out when the tag is not attached to a BaseObject
    node = op.GetObject()
    if node is None:
        return

    # Get out when the position cache, PREVIOUS_POSITION, has not been yet
    # initialized.
    global PREVIOUS_POSITION
    if PREVIOUS_POSITION is None:
        PREVIOUS_POSITION = node.GetMg().off
        return

    # Compute the position delta and get out when it is the null/zero vector,
    # i.e., nothing happened.
    nodeMg = node.GetMg()
    currentPosition = nodeMg.off
    positionDelta = currentPosition - PREVIOUS_POSITION
    if positionDelta == NULL_VECTOR:
        return

    # Now we are going to compute the angle of rotation similarly to what you
    # did as a ratio of arc length (of travel) to circumference.

    # Compute the circumference of the traveling object as the maximum radius
    # of its bounding box. This also could be done for a non spherical case,
    # but would get quite a bit more complicated.
    boundingBoxRadii = node.GetRad()
    travelObjectCircumference = 2 * math.pi * max(boundingBoxRadii.x,
                                                  boundingBoxRadii.y,
                                                  boundingBoxRadii.z)

    # The traveled distance since the last update, i.e., the arc-length of the
    # angle of rotation.
    travelDistance = positionDelta.GetLength()

    # The angle of rotation, based on the arc-length to angle of rotation
    # relation:
    #
    #   arc_length        theta
    # --------------- = ---------
    #  circumference       2π
    #
    theta = travelDistance / travelObjectCircumference * 2 * math.pi

    # Now we are going to construct a transform for that angle. First we are
    # going to construct our axis rotation which is orthogonal to the travel
    # vector and an arbitrary up-vector, i.e., we simply assume one degree or
    # otherwise would have to also track the banking of the traveling object.

    axisRot = ~positionDelta % UP_VECTOR

    # Now we are just computing our final desired transform, we could do this,
    # i.e., constructing a transform out of an axis and an angle, manually but
    # since the Python SDK does offer RotAxisToMatrix, we are going to be lazy
    # and just use that :)
    transform = c4d.utils.RotAxisToMatrix(axisRot, theta)

    # Now we are just going to write this into the object's transform in world
    # space, i.e., what Cinema does call its global matrix.
    mg = node.SetMg(nodeMg * transform)

    # And we have to update our position cache at the end.
    PREVIOUS_POSITION = currentPosition

Dear community,

in the context of the topic CKey Auto Tangents we did discover that the Python bindings for CCurve.GetTangents() are broken and will raise erroneously the "TypeError CCurve.GetTangents() takes no arguments (1 given)". There is unfortunately nothing one can do about this from the user side.

This issue will be fixed with an upcoming version of the SDK.

Thank you for your understanding,
Ferdinand

Hello @aimidi,

so, I did revisit your problem and CKey::GetValueLeft/Right and CKey::GetTimeLeft/Right do indeed not work with key presets. They will always return the non-adjusted values for the key, i.e., what equates to the preset CUSTOM. It is a bit a matter of opinion if this could be considered a bug or not, since there are some indicators in our code that this has been implemented intentionally in this way for performance reasons.

If you want to retrieve the true tangents for a key, i.e., the tangents which take the presets into account, you must use CCurve::GetTangents where the documentation already states that they do this.

Currently there is no warning in the docs that CKey::GetValueLeft/Right and CKey::GetTimeLeft/Right will behave in this way. I will reach out to the developers if we want to change this behavior. If we do not, we will update the documentation of CKey::GetValueLeft/Right and CKey::GetTimeLeft/Right in an upcoming release to reflect that this will always return the underlying custom tangents (which are sort of invisibly always there).

Below you will find a code example in C++ and the matching output which should be what you are after.

Sorry for the longwinded thread and cheers,
Ferdinand

The output:

The code:

// For https://plugincafe.maxon.net/topic/13344

#include "c4d.h"
#include "c4d_symbols.h"

static maxon::Result<void> pc13344(BaseDocument* doc)
{
    iferr_scope;

    BaseObject* op = doc->GetFirstObject();
    if (op == nullptr) {
        ApplicationOutput("Please insert at least one object into the scene.");
        return maxon::OK;
    }

    CTrack* track = op->GetFirstCTrack();
    if (track == nullptr) {
        ApplicationOutput("The first object in the scene has no animation track.");
        return maxon::OK;
    }

    CCurve* curve = track->GetCurve();
    if (curve == nullptr) {
        ApplicationOutput("The first object's animation track has no curve/keys.");
        return maxon::OK;
    }

    for (int index = 0; index < curve->GetKeyCount(); index++)
    {
        CKey* key = curve->GetKey(index);
        CKEYPRESET preset = key->GetKeyPreset();

        maxon::Float keyTleftX = key->GetTimeLeft().Get(), 
                     keyTleftY = key->GetValueLeft(), 
                     keyTRightX = key->GetTimeRight().Get(), 
                     keyTRightY = key->GetValueRight();

        maxon::Float64 curveTleftX = 0., curveTleftY = 0., curveTRightX = 0., curveTRightY = 0.;
        curve->GetTangents(index, &curveTleftX, &curveTRightX, &curveTleftY, &curveTRightY);

        ApplicationOutput("index: @, mode: @, keyLeftTangent: (@, @), keyRightTangent: (@, @), 
                           curveLeftTangent: (@, @), curveRightTangent: (@, @)",
                          index, preset, 
                          keyTleftX, keyTleftY, 
                          keyTRightX, keyTRightY, 
                          curveTleftX, curveTleftY, 
                          curveTRightX, curveTRightY);
    }
    return maxon::OK;
}

Hello @johntravolski,

I am glad that it worked for you.

Is there any way to get the Python shader to work in the viewport (not be completely black)? Or is it just too slow for that?

No, Python shaders do come with a preview in the viewport (which is just a cached low-resolution bitmap as defined in the material settings). You do not have to do anything special for that. If I would have to take a guess, I would assume that you assign the material to the geometry of the complex surface you do return as the generator cache of your ObjectData/Python Generator object, right? I am not sure if this has been already said in this thread but providing materials for generator caches is sort of a "hack" or unintended use of Cinema 4D SDK. I have not tried this myself, but sending myComplexShader.Message(c4d.MSG_UPDATE) and myMaterial.Message(c4d.MSG_UPDATE) might help. You also could try to execute passes on that material in a temporary document. But there is a good chance that this all will not work and that you must assign the material to the generator and not the cache as Cinema otherwise will not build the viewport bitmap caches for it.

The Python shader is very slow to render [...]

Yes, it pains me to say that, but my beloved Python is not a particularly good language to write shaders in. It is not only that iteration is slow in Python, but also the sheer number of calls to MyShader::Output that will really slow a Python shader down. Even for an algorithmically simple shader this can mean adding multiple seconds to the render time of a document (depending on the view coverage and number of calls to your shader). So, yes, C++ will make things considerably faster here.

Cheers,
Ferdinand

Hello @karpique,

About my concept: I’m trying to make procedural “current state to object” where result base object remains the same and only thing that changes is its mesh.

1. Depending on how you mean that, a solution to this ranges from trivial to extraordinarily complex. It mostly depends on your interpretation of procedural. If you just want a static one-way binding from some input X to a generator object, i.e., have an output that is not editable, then this is not hard to do. Simply write a Python Generator Object or ObjectData plugin which uses SendModelingCommand to execute MCOMMAND_CURRENTSTATETOOBJECT on that input in a temporary document and return the result of that as the cache of the generator.
2. If you however want this to be a non-static one-way binding, i.e., have the result of MCOMMAND_CURRENTSTATETOOBJECT copied into an editable mesh, this can become extremely hard to do, because this goes a bit against the principal logic of Cinema 4D. If you have an input (hierarchy) In and an output geometry Out, you could write a tag solution that simply does copy stuff from In into Out whenever it determines In to be dirty. It could also be done as an ObjectData solution, as either providing your own PolygonObject or a deformer. At least the tag solution is not much harder to do than what is being described under point one. But if you want to have some sort of persistence in modifications made by the user to Out, this will become quite complicated. Because if the user just moves the polygon with the ID 1, you might want to preserve this modification after the user modifies then In resulting in an output that also contains a polygon humans would consider to be the same as the polygon 1 from the previous output. The solution to this range from simple, like for example only preserving transformation changes made to outputs for the same point and polygon count, to complex and preserving arbitrary modifications via some form of similarity measure. Due to that inherent complexity, we cannot provide support for this, as these would be design decisions - which are out of scope of support according to our Forum and Support Guidelines.

As far as I know c4d.utils.SendModelingCommand will create new object, so its not the case. Copying polygon and point tags is super fast so I hope there is some way to keep this operation in sync.

I do not understand what here the question is.

For instance, how VertexColorTag being resized if MCOMMAND_DELETE applied? Does SendModelingCommand held that or something else?

VariableTag instances, e.g. a VertexColorTag, adapt themselves to modelling operations carried out on thier hosting geometry, no further actions are needed. C4DAtom.CopyTo is however not a modelling operation but replaces the content of one object with that of another (assuming they are of matching type). There is no way to notify the VertexColorTag of such 'change' since it has no clue how to map the old to the new data. If the new data happens to be of the correct size, it will work without any further actions, since the VertexColorTag does not care about topology, but mismatching sizes it can lead to crashes.

Cheers,
Ferdinand

Hello @bentraje,

no need to be sorry and thanks for closing it

Cheers,
Ferdinand

Hi @AiMiDi,

ah, I now do understand, you are right, these outputs look indeed to be wrong, I totally overlooked that. I will have to take a closer look if this is a bug, or you and I simply misunderstand the purpose of these methods. As I would also expect them to effectively provide a tangent vector relative to the key vertex.

Cheers,
Ferdinand