Duh, I need to type faster.

@bentraje Try the BFM_xxx messages for gadget interaction, not MSG_CHANGE.

(and no KillEvents in your case)

Without explicitly testing: You are changing the slider (InitValues) while you are still checking the message. Which probably generates a new message, which calls Message again, etc.

The least thing you can do is NOT call InitValues if the slider is already at 0.0.

I'm not sure anyway whether the code will do what you want, as any tiny movement of the slider will accumulate into a finger rotation (even while the user is still dragging the slider). I bet it would just start spinning out of control, or become unresponsive...

well, as for Q1 you did write MAXON_IMPLICITE with an E at the end in your code, so the compiler doesn't know that...

For simplification, we'll assume that world, bend, and object coordinates are all the same.

Now you can draw a circle with radius r and check where a point p is going. Let's just look at the point p = (L,0) - the farthest centered point of our object, or the center of the coordinate system of out object if you want to move a whole object.

Then p'.x is going to be r * sin(alpha), and p'.z will be r - r * cos(alpha), as per the definitions of sine and cosine.

And that's all there is! Okay, after you did the necessary coordinate transformations between the base coordinate systems and adapted the calculation for other points than p, but that's homework.

Here I made a little scene where a Python tag does the calculation. A flattened cube is bent by a bend deformer; a torus primitive is moved accordingly to stay flush with the left edge of the cube. Note that the calculation for the torus position and rotation is done solely through the Python tag, whose only input the bend deformer's angle is, so the Python tag is actually replicating the bend deformer functionality.

20200104_CenterOfBendDeformer.c4d

The main part is the code of the Python tag (I'm calculating with radians here so don't wonder why there is no pi; also the bend deformer in my scene is pointing to the negative x so we have additional minus signs:

import c4d
from math import sin, cos

def main():
    torus = op.GetObject()
    source = torus.GetPred().GetDown()
    strength = source[c4d.DEFORMOBJECT_STRENGTH]
    originx = -400.0
    originz = 0.0
    if strength == 0.0:
        targetx = originx
        targetz = originz
        roth = 0.0
    else:
    
        alpha = strength
        radius = originx / alpha
    
        targetx = radius * sin(alpha)
        targetz = -(radius - radius * cos(alpha))
        
        roth = -alpha
    
    torus[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_X] = targetx
    torus[c4d.ID_BASEOBJECT_REL_POSITION,c4d.VECTOR_Z] = targetz
    torus[c4d.ID_BASEOBJECT_REL_ROTATION,c4d.VECTOR_X] = roth

Obviously this is a very simplified sample that works only for this scene, but you can adapt the calculation for yours.

okay, calculate with me...

The arc length L for an angle alpha on a circle with radius r is L = 2* pi * r * alpha / 360
(assuming alpha is in degree). alpha is known; it is the bend angle.
The arc length is also known - it's the distance of the bending point to the center of the bend
(assuming we want to keep that length constant).
The radius is actually the wanted value. So we transform
L * 360 = 2 * pi * r * alpha
(L * 360) / (2 * pi * alpha) = r
Obviously, this is numerically bad since with alpha approaching 0, r is approaching infinity. But maybe we can solve this in the transformation and get rid of either alpha or r.

The rotation of the target coordinate system (the object to place on the bend) is obviously alpha itself.
The position p of the target needs to be moved according to sin and cos of alpha on the circle with radius r.

Remember that all of this needs to be expressed in the coordinate systems of either the object, the world, or the bend deformer, which makes the calculation perhaps a bit awkward.

@zipit @mfersaoui not quite; the pivot of the rotation is also changing (only along one axis, but still...), and it's not a linear movement but some exponential one between 0 (approaching only) and infinity (when no bend). The infinity one may also be tricky numerically.

I have an idea how to solve (my Google-fu seems weak on this) but haven't tried in praxis yet.

@mfersaoui If you're generating the objects on the fly, you wouldn't need a Python tag but could place the objects in their "bent" placement already, so that would not be a problem. Of course, if you can't replicate the bending algorithm the question is moot... but maybe Google knows the fitting formula?

If I understand the code correctly, you are only using it for generating the structure, and you rely on the Bend deformer completely to create the repositioning.

What if you lose the bend deformer, and use a Python tag instead that creates the bend effect "manually" - based on not the polygons (which you don't deform in your screenshot anyway) but on the object matrix of the affected objects, which would then apply to the lights as well? Is that wavy motion in the screenshot all you want to generate, or is there more to it?

@blastframe good... although the question would be why it works for me without that. Then again it is entirely possible that some other plugin that I have installed has the side effect of updating all tags under certain circumstances...