Posts made by Cairyn

@esan Your first version does not assign the string(s) to anything - a return is missing. What pythonNodeCode() is actually doing is to define a number of strings that are then discarded, and to return None as this is the default.

You can write it line by line if you add the \n manually to each line, and force Python to concatenate the strings by using line continuation \

def pythonNodeCode():
    return \
        'import c4d\n'\
        'def main():\n'\
        '    global Output2\n'\
        '    global Input3\n'\
        '    Output2 = c4d.BaseList2D.GetName(Input3)\n'\

I don't quite see why triple quotation should not work, maybe same issue?

def pythonNodeCode():
    return '''

import c4d

def main():
    global Output2
    global Input3

    Output2 = c4d.BaseList2D.GetName(Input3)
'''

@esan Your Python node and code do not match up. You have renamed the ports to Link and String but in your code the globals that are supposed to connect to the ports are named Output2 and Input3. This must be consistent.

You can write the call to GetName easier as well by invoking it on the object (the input port).

import c4d

def main():
    global TheLink, ObjName # ports
    ObjName = TheLink.GetName()

Assuming you mean a regular polygon, the maximum rounding radius is the same as the incircle of the polygon (as at this point all roundings touch and form a circle).

For formulas, see e.g.
https://www.mathopenref.com/polygonincircle.html

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...

@blastframe Nope, I'm on a PC, R21 (newest fix). I copied your script from the post and it worked from the start, the attribute manager changes, the display of the axes in the viewport change, the behavior changes. It works as well with the constant and no name check - in the past, I had some weird issues with changing numeric "constants", that's why I asked about using the c4d.Tprotection one. But I cannot find any error whatsoever.

I would say you could notify the tag itself of a change, but then... it does work without that, so I have no explanation, sorry.

@blastframe Works fine for me actually.

Did you try to replace the numeric value by c4d.Tprotection? Is it necessary to check the type name as well? Did you try to just print the type value and name to the console to check? Does the loop find the tag but just doesn't set the values, or does it not find the tag at all?

As you cannot instantiate deformers (they do appear but don't do anything) I would say the only way is to create a second deformer for the "other" object, and use XPresso to connect that deformer to the "original" deformer.

The scope of a deformer is set by the parent object or parallel objects in the same hierarchy, not explicitly by some slots (like effectors), so it's just not working like Maya I'm afraid.

Actually, Python works differently from C++. A "global" variable there is only global for the current execution context. In Python, variables are not declared; Python creates them when they are first used ("first" meaning, there is no such variable in the current execution context already).

Where a C++ global variable is created at compile time and represents one location in memory throughout, Python globals are created at runtime in their context. Cinema 4D has one context per Python element, so if you are accustomed to C++ globals, the following will irritate you:

• Create two objects with a Python tag
• Write the following code into the tags:

import c4d

def main():
    global x

    if doc.GetTime().GetFrame(doc.GetFps()) == 0:
        x = 1
        print "Tag 0 x set to 1"
    else:
        print "Tag 0 x = ", x
        x += 1

for one tag, and

import c4d

def main():
    global x

    if doc.GetTime().GetFrame(doc.GetFps()) == 0:
        x = 0.5
        print "Tag 1 x set to 1/2"
    else:
        print "Tag 1 x = ", x
        x += 1

for the other. Obviously, the first tag counts on full integers and the second on halfs, both are reset on frame 0.

The output amounts to

Tag 0 x set to 1
Tag 1 x set to 1/2
Tag 0 x =  1
Tag 1 x =  0.5
Tag 0 x =  2
Tag 1 x =  1.5
Tag 0 x =  3
Tag 1 x =  2.5
Tag 0 x =  4
Tag 1 x =  3.5
Tag 0 x =  5
Tag 1 x =  4.5
Tag 0 x =  6
Tag 1 x =  5.5
Tag 0 x =  7
Tag 1 x =  6.5
Tag 0 x =  8
Tag 1 x =  7.5
Tag 0 x =  9
Tag 1 x =  8.5
Tag 0 x =  10
Tag 1 x =  9.5

Obviously, although both tags claim a global x, they access different x's. That's because their contexts are different. Which also means that they cannot exchange data through globals this way. (You can try with an external module that you import, but I don't have time to verify that at the moment.)

If all you want is to store a value between executions of a tag, this is easy to implement this way. However:

• You must make sure that Python creates the variable at some point. Here, I did that through a first value setting at frame 0. Which also means that every time the timeline passes through 0, the value is reset.
• You must pay attention to the evaluation of the object tree. I chose a tag here since the tag is evaluated with the tree every time. That is NOT the case for a generator, as there are caching mechanisms at work.
• You must take care of situations like "jumping around in the timeline", replaying backwards, setting the time explicitly through some other plugin, and such.

@JasenLux said in Automate Turbosquid uploading with Python script:

Even if in the morning I've got a bunch or renders done over night - and it's all automated - I'd be very happy.

A more or less automated rendering could be achieved by using the native Render Queue if you create your files with some rigid discipline.

Start out by creating a base C4D file that contains the necessary cameras and render settings with some appropriate naming. The render settings should be hierarchically ordered, with the basic setting on top and all the different resolutions as children of that setting, with only the necessary settings overwritten.

If there are TurboSquid requirements that you cannot achieve with render settings, you can create some takes that offer the necessary changes (this might be the most difficult part, as you may need to overwrite parameters in tags that you don't have in the basic file, but only create with your project, but that very much depends on what you really need to change, I am not familiar with the TurboSquid requirements.

Once that file is set up, you only need to copy your master data into that, save it under the appropriate name, and in the evening add it a few times to the render queue. As you can select the take, rendersetting, and camera for each job, the prepared file can be rendered out without saving multiple versions of it first.

(That sounds like some script would make it easier, too, but I just fleetingly looked at the Python and C++ documents about BatchRender, and it doesn't look as if you can control the job settings individually?)

I recognize that this would only be good for the rendering part, but... if TurboSquid doesn't offer an official, supported web interface for uploading, then as @zipit said, "hacking" into the protocols would be just one gigantic mess that you don't really want to spend money on as it is very likely to break at the first opportunity.

Thanks for mentioning me ;-)

ah, great. I should try the last solution first, next time ;-)

Looks just like mine, so no errors there.

Okay, last try for today: Is your plugin project in the project explorer displayed as bold text? If not, try context menu -> Set as start project (or however the menu point is called in English)

If that doesn't work either, I need to leave the issue to the specialists ;-)