Posts made by ferdinand

Hello @kilou,

welcome to the forums and thank you for reaching out to us. Please make sure to read the Forum Guidlines, as your posting is missing critical information, which we require users to add in form of tags.

For your question:

1. The BaseDarw.DrawHUDText method is very much different from the one used internally by Cinema 4D. DrawHUDText does not support antialiasing. You can somewhat circumvent the problem by drawing a bitmap, but that approach comes with its own problems. See Draw HUD-like text to viewport for details.
2. You cannot on top of safe frames inside NodeData.Draw as this would defeat the purpose of safe frames. What you can do is draw in relation to the safe frame. See end of posting for details.

Cheers,
Ferdinand

    def Draw(self, op, drawpass, bd, bh):
        """Draws text into the passed BaseDraw.
        """
        # If the current draw pass is not the highlight draw pass, we skip 
        # this call. We cannot draw over the safe frames with any of the draw
        # passes as this would defeat the purpose of the safe frames of
        # blocking stuff out.
        if drawpass != c4d.DRAWPASS_HIGHLIGHTS:
            return c4d.DRAWRESULT_SKIP

        # Drawing in screen space does not take account of the safe frames
        # automatically, but we can get hold of them.
        bd.SetMatrix_Screen()

        # Get the frame of the safe frame.
        safeFrame = bd.GetSafeFrame()
        # The left and top offsets of the safe frame.
        cl, ct = safeFrame["cl"], safeFrame["ct"]

        # Draw at the point (5, 5) in the safe frame.
        bd.DrawHUDText(cl + 5, ct + 5, "Perspective")
        return c4d.DRAWRESULT_OK

Hello @JohnTerenece,

I was able to reproduce your problem, but I am frankly myself a bit perplexed why it is happening. At the end of the posting you will find a sort of solution.

Let us first establish some conditions:

• The problem seems completely independent from scrollbars or the size of the Attribute Manger.
• The length of description elements seems to also have no impact.
• But the presence of a Voronoi Fracture Object is indeed a triggering factor.
• What seems to be happening is that the redraw of the Attribute Manger is only done partially. What you did report as these horizontal lines, is actually the border between the old redraw and the erroneously placed new redraw of the Attribute manger.
• This only happens under very specific conditions: Create an instance of your plugin, then an instance of the Fracture Object, and switch back to your plugin object.
• Other plugins that do similar things in GetDDescription, e.g., my PC13488 example posted here or the SDK C++ MorphMixer plugin do not suffer from the same problem.

What stood out to me, is that you do pass the flag DESCFLAGS_DESC::RECURSIONLOCK which will prevent GetDDescription being called again (and is also marked as private, which usually should be read as a warning that one should know exactly what one is doing when using the stuff marked as private). But removing that flag alone, for which I do not fully understand the purpose in your case, won't fix your issue. What will however sort of fix the issue, is to bail the execution when that same flag is being passed in:

Bool BreakSpline::GetDDescription(GeListNode *node, Description *description, DESCFLAGS_DESC &flags)
{
  // Bail when we are not meant to execute GetDDescription.
  if (flags & DESCFLAGS_DESC::RECURSIONLOCK)
    return false;

  // Your stuff  
  if (!description->LoadDescription(node->GetType()))
    return false;
    BaseObject* op = static_cast<BaseObject*>(node);

    if (op == nullptr)
        return FALSE;

    ...
  // End of your stuff.

  // Haven't tried if the problem reappears if one passes in RECURSIONLOCK
  // again here. I just removed it as one the first things and kept it then
  // like this.
  flags |= DESCFLAGS_DESC::LOADED; // | DESCFLAGS_DESC::RECURSIONLOCK;
  return SUPER::GetDDescription(node, description, flags);
}

This will make the problem disappear for me. The reason why I called this a "sort of"-solution, is that this smells very much like a bug caused by the Fracture object or the RECURSIONLOCK flag which somehow seems to bleed from one plugin into another, but most surprisingly not in the case of my almost identical PC13488 plugin or the SDK C++ Morphmixer plugin which is also quite close. But this bailing on RECURSIONLOCK is something which is done internally by us, so maybe this is some sort of known limitation.

Please let me know if this solved your problem.

Cheers,
Ferdinand

Hello @robkom,

yes, you will need to implement some NodeData derived type, e.g., an ObjectData plugin. You can skip most of its implementations, and only have to implement parameter and gui related stuff. The most minimal implementation would be to only implement NodeData.Init(Link) to initialize the node parameters. In your dialog, you then have to create an instance of the node and attach it to the DescriptionCustomGui. Not rocket science, but still a bit of an advanced technique. Your parameters will then be obviously attached to the node and not the dialog. So, when you want to read out something in the context of the dialog, you won't read it from the dialog anymore, but from the node.

I have shown in this thread how to display a node within a GeDialog. In the example I display the internal preferences node and did not create my own node, but it shows you at least partially the workflow. Implementing such node to display will not differ from any other node implementation, it is only that you do not need to implement any of the logic related methods like GetVirtualObjects for a polygonal generator object, since you are only interested in the GUI of the node.

Cheers,
Ferdinand

Hello @robkom,

thank you for reaching out to us. As pointed out by @AiMiDi, there is a difference between GeDialog and Description resource. Which is why some stuff is not supported in dialogs.

The GeDialog resources do not support all functionalities of all resource elements. The SplineCustomGui is such case. Your options are:

1. Wrap around a description resource in your dialog.
   • Implement a node with the spline gui element in its description.
   • Display the node in a c4d.gui.DescriptionCustomGui inside your dialog.
2. Create the required additional interface elements on your own with the tools provided by GeDialog.

Cheers,
Ferdinand

Hello @johnterenece,

so, I gave your problem yesterday a spin, and I was unfortunately unable to reproduce it. You will find at the end of the posting the exact setup I did use.

When I ran the example code (with some minor modifications) I had no "stripes". I ran the plugin alongside a Voronoi fracture object and also made sure that the Attribute manger had both horizontal and vertical scroll bars. Which either means I inadvertently fixed your code or there are other factors at play. I would propose that you look at my example and see if any of the comments in it help (there were some problems in your code). Please also make sure to not post fragments in the future, i.e., post a complete version of GetDDescription which is compileable, as it will otherwise always be a guessing game for us. If this does not help, which I somehow suspect will be the case, we will need more information from you:

• The exact revision of Cinema 4D with which the problem occurs. I ran R23 SP1 (R23.110), are you on SP2?
• The OS enviornment(s) you are in.
• The description resource you are using.
• The whole ObjectData implementation of the example. Are you interfering with description related messages in NodeData::Message?

As stated in our forum guidelines, you can send us data confidentially if it becomes necessary.

Cheers,
Ferdinand

The result:

The code:

/* Test for PC13488 GetDDescription troubles.
* 
* User reports that running a Voronoi fracture object alongside this plugin will cause horizontal
* glitches in description elements.
*/

#include "c4d.h"
#include "c4d_symbols.h"
#include "lib_description.h"
#include "pc13488.h"
#include "main.h"

#define ID_PC13488 1057997
#define ID_SOMEGROUP 98765
#define DYNAMIC_ELEMENTS_COUNT 25

class PC13488 : public ObjectData
{
    INSTANCEOF(PC13488, ObjectData)

public:
    virtual Bool Init(GeListNode* node);
    virtual Bool GetDDescription(GeListNode* node, Description* description, DESCFLAGS_DESC& flags);

    static NodeData* Alloc() { return NewObjClear(PC13488); }
};

Bool PC13488::Init(GeListNode* node)
{
    BaseObject* op = (BaseObject*)node;
    BaseContainer* data = op->GetDataInstance();
    if (!data)
        return false;
    return true;
}

Bool PC13488::GetDDescription(GeListNode* node, Description* description, DESCFLAGS_DESC& flags)
{
  // Bail if there is no description for this node type. You did omit exiting here, which makes
  // little sense to me, since if there is no description, you cannot modify it.
  if (!description->LoadDescription(node->GetType()))
    return false;

  // Bail if we cannot get hold of the tangible node, i.e., the BaseObject.
  BaseObject* op = static_cast<BaseObject*>(node);
  if (op == nullptr)
    return false;

  // Removed some unused variables here.
  const DescID* singleid = description->GetSingleDescID();
  DescID cid;

  // Had to modify this, since you used a symbol undefined in your example code.
  DescID descGroup = DescLevel(2000, DTYPE_GROUP, 0);
  if (!singleid || descGroup.IsPartOf(*singleid, NULL))
  {
    BaseContainer bc;
    bc = GetCustomDataTypeDefault(DTYPE_GROUP);

    // What confuses me a bit is that you also call this group "Object", because that is already
    // the name of the group with the id ID_OBJECTPROPERTIES, i.e., the default generator object
    // group.
    bc.SetString(DESC_NAME, "Custom Object Group"_s);
    bc.SetInt32(DESC_COLUMNS, 1);
    bc.SetFloat(DESC_DEFAULT, 1);
    bc.SetBool(DESC_SCALEH, TRUE);
    bc.SetBool(DESC_DEFAULT, TRUE);

    // Had also to modify this for the same reason, I attached the group to the root, i.e., this
    // group will be its on tab. You should also return false when setting the parameter fails, as 
    // this seems a bit more appropriate, but it should not make a big difference in "normal" 
    // operation where nothing goes wrong.
    if (!description->SetParameter(descGroup, bc, DESCID_ROOT))
      return false;
  }

  // From here on out it gets a bit chaotic, as you do use these hard-coded, non-consecutive, high 
  // value range IDs which are a bit hard to follow. But apart from being odd, there is nothing
  // wrong about it. I did replace at least the group id by a symbol. 
  DescID descTestGroup = DescLevel(ID_SOMEGROUP, DTYPE_GROUP, 0);
  if (!singleid || descGroup.IsPartOf(*singleid, NULL))
  {
    BaseContainer bc;
    bc = GetCustomDataTypeDefault(DTYPE_GROUP);

    bc.SetInt32(DESC_COLUMNS, 2);
    bc.SetInt32(DESC_DEFAULT, 1);
    bc.SetBool(DESC_SCALEH, FALSE);

    if (!description->SetParameter(descTestGroup, bc, descGroup))
      return false;
  }

  cid = DescLevel(987650, DTYPE_REAL, 0);
  if (!singleid || cid.IsPartOf(*singleid, NULL))
  {
    BaseContainer bc;
    bc = GetCustomDataTypeDefault(DTYPE_REAL);

    bc.SetInt32(DESC_UNIT, DESC_UNIT_METER);
    bc.SetInt32(DESC_STEP, 1);
    bc.SetInt32(DESC_DEFAULT, 0);
    // Added X's to make clear if there is some unwanted truncating going on.
    bc.SetString(DESC_NAME, "Offset                                                                      X"_s);

    if (!description->SetParameter(cid, bc, ID_SOMEGROUP))
      return false;
  }

  cid = DescLevel(987649, DTYPE_BOOL, 0);
  if (!singleid || cid.IsPartOf(*singleid, NULL))
  {
    BaseContainer bc;
    bc = GetCustomDataTypeDefault(DTYPE_BOOL);

    bc.SetInt32(DESC_CUSTOMGUI, CUSTOMGUI_BOOL);
    bc.SetString(DESC_NAME, "Fields   X"_s);
    bc.SetBool(DESC_DEFAULT, FALSE);

    if (!description->SetParameter(cid, bc, ID_SOMEGROUP))
      return false;
  }

  cid = DescLevel(987648, DTYPE_REAL, 0);
  if (!singleid || cid.IsPartOf(*singleid, NULL))
  {
    BaseContainer bc;
    bc = GetCustomDataTypeDefault(DTYPE_REAL);

    bc.SetInt32(DESC_UNIT, DESC_UNIT_METER);
    bc.SetInt32(DESC_STEP, 1);
    bc.SetInt32(DESC_DEFAULT, 0);
    bc.SetString(DESC_NAME, "Offset          X"_s);

    if (!description->SetParameter(cid, bc, ID_SOMEGROUP))
      return false;
  }

  // Tell Cinema that we did modify the description and call the base implementation.
  flags |= DESCFLAGS_DESC::LOADED;
  return SUPER::GetDDescription(node, description, flags);
}

Bool RegisterPC1057997()
{
    return RegisterObjectPlugin(ID_PC13488, "pc13488"_s, OBJECT_GENERATOR, PC13488::Alloc, "pc13488"_s, nullptr, 0);
}

The res file:

CONTAINER pc13488
{
  NAME pc13488;
  INCLUDE Obase;
  
  GROUP ID_OBJECTPROPERTIES
  {
    STATICTEXT ID_SOMESTATICSTUFF { }
  }
}

The .h file (of the description):

#ifndef pc13488_H__
#define pc13488_H__

enum
{
    ID_SOMESTATICSTUFF = 1000,
};

#endif // pc13488_H__

The .str file:

STRINGTABLE pc13488
{
    pc13488 "pc13488";
    ID_SOMESTATICSTUFF "A static text";
}

Hello @Ling,

thank you for reaching out to us. Please remember to open a new topic of you own when you have a question and not to hijack other topics. The exception to that rule is when you have a question that aligns exactly with a currently ongoing topic. The reason we enforce this, is so that the form remains a nicely searchable knowledge base. I have forked your question for that very reason; it did not align with the other topic.

About your question: It depends on what you mean by it. You cannot modify the background color of a Button element. What you can do, is create a LONG element and define QUICKTABRADIO as its custom GUI; here is how the muscle object in Cinema makes use of this GUI element:

LONG ID_CA_MUSCLE_OBJECT_STATE
{
    SCALE_H; ANIM OFF; PARENTCOLLAPSE;
    
    CUSTOMGUI QUICKTABRADIO;
                
    CYCLE
    {
        ID_CA_MUSCLE_OBJECT_STATE_RELAX;
        ID_CA_MUSCLE_OBJECT_STATE_COMPRESSED;
        ID_CA_MUSCLE_OBJECT_STATE_EXTENDED;
    }
}

This will give you the tabs look as shown in many places in Cinema 4D. You will however need multiple elements to make this useful, as this is effectively an options group. What you could also do, is create a BITMAPBUTTON and then have different images for its normal and pressed stated.

Cheers,
Ferdinand

Hello @indexofrefraction,

without further questions or replies, we will consider this topic as solved by Thursday and flag it accordingly.

Just for clarification: This does not mean that the bug is solved or that we won't track it, we simply do not want to keep the thread open until the bug has been fixed. The bug status is tracked with the to fix tag that has been added to the topic. We will report back here when the bug has been fixed.

Thank you for your understanding,
Ferdinand

Hello @indexofrefraction,

without further questions or replies, we will consider this topic as solved by Thursday and flag it accordingly.

Thank you for your understanding,
Ferdinand

Hello @jochemdk,

thank you for reaching out to us. I am not sure if your postings are questions, please remember to open a new thread for questions of your own. @m_magalhaes is also currently on vacation, so he will not respond here any time soon.

Thank you for your understanding,
Ferdinand

Hello @stereo_stan,

welcome to the forum and thank you for reaching out to us. Please make sure to read for further posting the forum guidelines. Your posting is missing tags for the programming environment, the version of Cinema 4D and your operating system environment.

You can add a button with GeDialog.AddButton(). For further details, please refer to the GeDialog documentation or have a look at our GeDialog code examples at GitHub when you are stuck on a more general level.

Cheers,
Ferdinand

Hello @everyone,

thank you @dskeithbuck for reaching out to us. There is not much to add for us here. Due to the lack of SceneHookData it is not possible to do what you want to do in Python. You cannot use MessageData, because it is not derived from NodeData and therefore has no Message method, the method to which MSG_DOCUMENTINFO is being broadcasted.

What you could try, is piggy backing onto SceneLoaderData or SceneSaverData as a SceneHookData replacement. I.e, only to use their Message method. But I cannot tell you when these two interfaces will receive messages. PreferencData for example, will only receive messages when the preferences dialog is open. You would have to try yourself if you could abuse them in such way. You should register them then for an extension which does not interfere with existing file formats.

Noteworthy seems also, that 'and possibly interrupt the save process if errors/issues are found' will not be possible, even when you return false for MSG_DOCUMENTINFO_TYPE_SAVE_BEFORE, Cinema will still save the document.

Cheers,
Ferdinand

Hello @orestiskon,

well, are you experiencing "drift"? I am not 100% sure what you mean by drift, but I assume you mean just an error with that.

As I lined out above, floating point error at 64 bits is usually not something you have to worry about in the scenario of what you are doing. There will be an error, but if you are only interested in visually representing something, it will be negligible when you meet the conditions I did line out above. I also do not get quite why you have to store the scale of the matrix. When you transform an input matrix with another matrix that has the scale of (1,1,1), then scale of the result will have the same scale as the input matrix, since x * 1 is still x.

In general, you try to avoid doing multiple arithmetic operations in a row (see example at the end). Which is also the reason I proposed interpolations. But again, for just moving a cube around, you should be fine.

Cheers,
Ferdinand

"""Showcases the impact of doing the same calculation in 'different' ways.
"""
import math

# List of ten 1.1's, 1.1 cannot be represented by 64 bit floats.
items = [1.1] * 10

# This will amass the precision error of ten additions of a not representable
# value.
print (sum(items))
# This won't.
print ((1.1 * 10))
# And this won't either.
print (9.9 + 1.1)
# One of Python's floating point tricks, fsum is addition with an error term.
print (math.fsum(items))

10.999999999999998
11.0
11.0
11.0

Hello @johnterenece,

thank you for explaining your problem inmore detail, I do understand your issue now.

Your code does nothing out of the ordinary on first glance, so I will have to investigate this myself. Which will take me some time to write a test case. I'll answer here once I have come to a conclusion.

Cheers,
Ferdinand

Hello @orestiskon,

this is a private answer of mine and I think @Cairyn has already given you a nice answer, but I would like to clarify some stuff. And to be clear: The question of yours is formally out of scope of support, you will have to rely for further answers on the community.

What is floating point precision?

e to the pi Minus pi, CC-BY-NC 2.5 XKCD

I cannot unpack this in all detail and am going for an intuitive understanding. For more details I would recommend the excellent Wikipedia article on Floating-point arithmetic.

So, you have probably seen popular examples for floating point precision errors like print(1.1 + 2.2), which will print 3.3000000000000003, accompanied by devastating statements like "the vast majority of real numbers cannot be represented in IEEE 754". While this is all true, it can be a bit misleading in my opinion.

So, let us try it out ourselves in Python, in order to figure out what that mysterious error is. We can run this code here:

# Used to force Python printing numbers with up to 51 decimal places, as 
# Python will start rounding otherwise.
PrintNumber = lambda n: print("{:.51f}".format(n))

n = 0.000000000000000444089209850062616169452667236328125

PrintNumber(4 + n)

Which will print the following:

4.000000000000000000000000000000000000000000000000000

Yikes, that is not correct, Python seems to have completely ignored that we did add n to four and just returned the number four. So, we did find that pesky floating point error? n seems to be some kind of limit which cannot be represented, right? Before we book this under solved, let us try two more calculations:

>>> PrintNumber(2 + n)
2.000000000000000444089209850062616169452667236328125
>>> PrintNumber(2 + n + n)
2.000000000000000888178419700125232338905334472656250

That is confusing, for the number two the the calculation is correct. And when we then add n to that result again, the new result is still correct. So, there seems to be more to floating point precision than just a fixed value. To understand what is happening, we need to understand at least roughly how floating point numbers are represented.

Other than whole numbers, real numbers are an uncountable set. Which means while there are infinitely many whole numbers, we can still start counting towards infinity, i.e., count 0, 1, 2, 3, .... For real numbers, which we are trying to represent with floating point numbers, this cannot be done. When we try to start counting from 0, we cannot even name the next element, since there is always a smaller one; e.g., 0.1 is not the next element, because 0.01 is smaller, which is not the next element, because 0.001 is even smaller, which is not the next element ... and so on. So, we need to pick a certain precision with which to represent real numbers on the computer, since we cannot handle infinite precision there.

Floating point numbers can be represented in many ways, but the dominant form is something called IEEE 754. These representations can come in different bit lengths: 16 bit (half), 32 bit (single), 64 bit (double), and 128 bit (quadruple) precsion. Cinema, Python and most software use dominantly 64 bit, i.e., double precision for floating point representation. These representations are composed of a exponent and an mantissa, for 64 bit their sizes are:

exponent: 11 bit as an unsigned integer
mantissa: 53 bit as an unsigned integer

Now we skip some nasty technial details, but we can realize a fundatental thing:

There are always two powers of two for a given real number. One which is the closest power of two which is smaller than the given number and one that is the closest power of two that is bigger.

So, for the number 3, the closest power of two which is smaller would be 2¹, i.e., 2, and the closest power of two which is bigger would be 2², i.e., 4. This information of between which powers of two a floating point number lies is stored in the exponent and forms an interval. For the example of 3, the smaller power of two was 2¹ and the greater power 2², so the interval is [2, 4]. The mantissa is an unsigned integer with a very high precision (53 bits, i.e. 2⁵² values) which does divide that interval into representable values. From which folllows that the precision for each interval is always the same, 53 bits, but the the length of the interval does change exponentially with the distance of the lower boundary of the interval to zero:

53 bit mantissa max value = 4503599627370496

Precision for from 2¹ to 2²:
    interval length = 2² - 2¹ = 2
    maximum error = 2 / 4503599627370496 = ‭4,4408920985006261616945266723633e-16‬

Precision for from 2² to 2³:
    interval length = 2³ - 2² = 4
    maximum error = 4 / 4503599627370496 = 8,8817841970012523233890533447266e-16

Precision for from 2³ to 2⁴:
    interval length = 8
    maximum error = 1,7763568394002504646778106689453e-15
...

Wikipedia has a nice visualization of that exponential distribution of precision for this form of floating point representation:

Visualization of floating point precision loss, CC-SA 4.0 Joeleoj123

From this we can come to a few conclusions:

• We can explain why 4 + n in our example from abov did not work and 2 + n did, as n is exactly the precision of the [2, 4] interval. And n is below the precsion of the next [4, 8] interval, which resulted in the result being rounded down to the closest value, 4.0. IEEE 754 rounds to the closest representable value.
• IEEE 754 can only represent numbers in the interval [2, 4] which are the sum of 2 and multiples of that precision n.
• For IEEE 754 doubles, there are 4,503,599,627,370,496 values in the interval [2⁰, 2¹], a range of 1 with a maximum error of 2,220446049250313e-16‬.
• For IEEE 754 doubles, there are also 4,503,599,627,370,496 values in the interval [2¹⁰²², 2¹⁰²³], a range of 4,49423284e307 with the mind boggling maximum error of 9,97920155e291. For comparison: There are approximately 1e82 atoms in the observable universe.
• Especially that last number should make clear that floating point precision error is not inherently a small value and that amyn bins have an error that is larger than one, which affects our abilty to represent integers with floats:
  • Integers from −2⁵³ to 2⁵³ can be represented exactly.
  • Integers between 2⁵³ and 2⁵⁴ round to a multiple of 2.
  • Integers between 2⁵⁴ and 2⁵⁵ round to a multiple of 4.
  • Integers between 2⁵⁵ and 2⁵⁶ round to a multiple of 8.
  • ...

Yikes, how do we deal with that?

There is no definitive answer to this as already pointed out by @Cairyn. If there would be a "Computers hate this: Five easy tricks to avoid floating point errors!", it would be integrated into hardware or compilers. @Cairyn named a few tricks which more or less work in some situations and there are also more advanced techniques. Some languages also have buildin-tricks up their sleeves, like for example Python with float.as_integer_ratio, math.fsum and the type decimal. But the fancy techniques and language tricks do not help much in your case, since language tricks won't work with c4d.Vector & c4d.Matrix and the fancy techniques usually aim more towards comparing and solving stuff.

It would have been better if you had shown something more concrete, but I assume you have basically a script which does something like the following:

import c4d

def main():
    obj = op.GetObject()
    mg = obj.GetMg()
    mg.off += c4d.Vector(1.1, 2.2, 3.3)
    obj.SetMg(mg)

So, each iteration of this script will pile up a bit of error. Because all the components of the vector we add are not representable as 64 bit floats in the first place and while we run the script, we will traverse through different intervals of precision. And when we do this long enough, we theoretically land at some time t at an offset where the error is larger than the value we do add. But when we assume a starting point of the object which is somewhere in a cube of the side length of 100,000 units at the origin, then the maximum combined error for moving 100 units per frame for 1,000,000 frames will be 0,00145 units. Which follows from:

100,000 units lies within [2¹⁶, 2¹⁷] -> max error:  1,4551915228366851806640625e-11‬

So, 64 bits floats are relatively robust when it comes to entertainment oriented CGI and their precision needs for visually representing something, as we usually have both sane frame counts and world units (which is not always given in games and why the can struggle with this). You will still run into floating point problems when you for example want to test if two vectors are parallel or when you have to solve complex equations. But if you want to improve your script anyways, then the best approach is to replace iteration with interpolation. The script of yours is in general problematic, because it couples the world state to the frame rate of the document, i.e., the position of your object at T=1.0 will be a different one in a document with 25 fps, compared to a document with 50 fps. An interpolation based approach will not have the problem. How you interpolate can vary, here are two very simple examples:

import c4d
import math

# The point the object does move away from.
ID_POINT_START = (c4d.ID_USERDATA, 1)
# The point the object does move towards.
ID_POINT_END = (c4d.ID_USERDATA, 2)
# The time span it takes to move from start to end.
ID_DURATION = (c4d.ID_USERDATA, 3)

def main():
    """Interpolate linearly between two points.

    This will "snap back" after ID_DURATION has passed.
    """
    # Get the object.
    obj = op.GetObject()

    # Current document time in seconds.
    t = doc.GetTime().Get()
    # The current offset.
    dt = math.fmod(t, op[ID_DURATION]) * (1. / op[ID_DURATION])
    # Interpolate the current position and write the value.
    p = c4d.utils.MixVec(op[ID_POINT_START], op[ID_POINT_END], dt)
    obj[c4d.ID_BASEOBJECT_ABS_POSITION] = p

import c4d

# The point the object does move away from.
ID_POINT_START = (c4d.ID_USERDATA, 1)
# The travel per second of the object as a vector.
ID_TRAVEL = (c4d.ID_USERDATA, 2)


def main():
    """Interpolate linearly with a starting point and a velocity vector.

    This will travel towards infinity.
    """
    # Get the object.
    obj = op.GetObject()

    # Current document time in seconds.
    t = doc.GetTime().Get()
    # Interpolate the current position and write the value.
    p = op[ID_POINT_START] + op[ID_TRAVEL] * t
    obj[c4d.ID_BASEOBJECT_ABS_POSITION] = p

These two will also be subject to floating point errors, but you will not carry around the error of previous calculations, since you do not depend on the state of the last frame. These are just two very simple examples, many things can be restated as interpolations.

Cheers,
Ferdinand

Hello @johnterenece,

thank you for reaching out to us. Unfortunately, your question is missing some information which makes it hard for us to answer it. From the looks of your screenshots, I would assume that you are on R23, right? Unclear is also to us:

1. What would you consider going wrong for your plugin in these screenshots?
2. How does the Voronoi Fracture come into play with this? If I am understanding you correctly, the error only does occur when you select the Voronoi Fracture object, your second screenshot. But a Voronoi Fracture does not incorporate the descriptions of other nodes into its own description (other than objects in general which incorporate some tags into their description.

Cheers,
Ferdinand

Hello @eziopan

thank you for reaching out to us. And thank you @Cairyn for providing an answer.

The warning note is there as certain things are not allowed to be done outside from the main thread, for details see Threading Information. Functionalities that are only intended to be used from the main thread will either refuse execution all-together outside form the main thread, like for example some redraw related stuff. But many of them will actually run, but the user might interfere with the program state and main loop in the main thread, causing Cinema 4D to crash in the worst case.

There are some methods which are called very often outside from the main thread like ObjectData.GetVirtualObjects, TagData.Execute, or ShaderData.Output. And there are some like NodeData.Message where you have a relatively good chance for being inside the main thread when they are called. This transfers to scripting object analogs of these methods, e.g., for the Python Programming Tag one can expect main() (equivalent of TagData.Execute) to run outside of and message (equivalent of NodeData.Message) inside of the main thread. But these are not guarantees, and one must check with c4d.threading.GeIsMainThread() if one is on the main thread or not, if one wants to rely on it. I have tried it out for the interaction tag, and most of its functions are called from the main thread when I tried it (except for some calls to draw). See example_1 at the end for details.

But this is still just what happend in my case in this one instance, and in the end, there is nothing which prevents some other entity calling C4DAtom.Message on your interaction tag from outside of the main thread and therefore pass this problem down to the message() function inside the tag. The best pattern to avoid these problems is to cache/delay such access or invoking of main-thread related stuff. See example_2 for details at the end.

Cheers,
Ferdinand

example_1 code:

import c4d

def mouseDown():
    print (f"mouseDown in main thread: {c4d.threading.GeIsMainThread()}")

def mouseDrag():
    print (f"mouseDrag in main thread: {c4d.threading.GeIsMainThread()}")

def mouseUp():
    print (f"mouseUp in main thread: {c4d.threading.GeIsMainThread()}")

def doubleClick():
    print (f"doubleClick in main thread: {c4d.threading.GeIsMainThread()}")

def onSelect():
    print (f"onSelect in main thread: {c4d.threading.GeIsMainThread()}")

def onDeselect():
    print (f"onDeselect in main thread: {c4d.threading.GeIsMainThread()}")

def onHighlight():
    print (f"onHighlight in main thread: {c4d.threading.GeIsMainThread()}")

def onUnhighlight():
    print (f"onUnhighlight in main thread: {c4d.threading.GeIsMainThread()}")

def draw(bd):
    print (f"draw in main thread: {c4d.threading.GeIsMainThread()}")

def message(id, data):
    print (f"message in main thread: {c4d.threading.GeIsMainThread()}")

example_1 output (I got):

mouseDown in main thread: True
mouseDrag in main thread: True
mouseUp in main thread: True
doubleClick in main thread: True
onSelect in main thread: True
onDeselect in main thread: True
onHighlight in main thread: True
onUnhighlight in main thread: True
draw in main thread: True
message in main thread: True
mouseDown in main thread: True
mouseDrag in main thread: True
mouseUp in main thread: True
doubleClick in main thread: True
onSelect in main thread: True
onDeselect in main thread: True
onHighlight in main thread: True
onUnhighlight in main thread: True
draw in main thread: True
message in main thread: True
mouseDown in main thread: True
mouseDrag in main thread: True
mouseUp in main thread: True
doubleClick in main thread: True
onSelect in main thread: True
onDeselect in main thread: True
onHighlight in main thread: True
onUnhighlight in main thread: True
draw in main thread: True
message in main thread: True
[more message calls]
draw in main thread: False
message in main thread: True
[more message calls]
draw in main thread: False

example_2 code:

"""Example for deferring an execution to the main thread.

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

import c4d

# Plugin ID of mine which I can guarantee is not used in your documents, 
# please register your own ID.
STORAGE_ID = 1057432
# Does not have to be a plugin id, since we use it inside our own BaseContainer
ID_AXIS_LOCK_STATE = 0
                    
def mouseDown():
    """Here we are accessing the data.
    """
    # Retrieve a copy of the tags container.
    tagContainer = tag.GetData()
    # Retrieve the data at STORAGE_ID.
    bc = tagContainer[STORAGE_ID]
    # Check if its "our stuff".
    if isinstance(bc, c4d.BaseContainer) and bc.GetId() == STORAGE_ID:
        # Print the state.
        print (f"Axis Lock State is: {bc[ID_AXIS_LOCK_STATE]}")

def message(id, data):
    """We just use message as a place where we assume often to be on the
    main thread.
    """
    # Ensure we are on the main thread, since it is not guaranteed, even in
    # message.
    if c4d.threading.GeIsMainThread():
        # Do whatever we want to do.
        state = c4d.IsCommandChecked(12153)

        # We could store state as a global variable or inject it into the
        # Python interpreter, but the former would make us dependent on the
        # volatility of the script module and the latter is not a great idea
        # either, although due to c4d.threading.GeIsMainThread() we would
        # ensure avoiding access problems.

        # Instead we are going to store the data in the tag. For that we
        # need unique plugin ID from plugin Café to reasonably well avoid id
        # collisions. We also give the container itself that ID so that we
        # can easily identify it as a container created by us.
        bc = c4d.BaseContainer(STORAGE_ID)
        bc[ID_AXIS_LOCK_STATE] = state

        # tag is predefined as the incarceration tag inside an interaction tag
        # script. We retrieve its data container instance.
        tagContainer = tag.GetDataInstance()

        # We retrieve the content in the tag's data container at STORAGE_ID
        # and when it is not None or a BaseContainer with the ID STORAGE_ID,
        # we bail, as something else is storing something there. Unlikely to
        # happen, but better safe than sorry.
        content = tagContainer[STORAGE_ID]
        is_container = isinstance(content, c4d.BaseContainer)
        # Bail if not a BaseContainer written by us.
        if is_container and content.GetId() != STORAGE_ID:
            return
        # Bail when not a BaseContainer and not None.
        elif not is_container and content is not None:
            return
        # Otherwise write our bc to the data container of the tag.
        else:
            tagContainer.SetContainer(STORAGE_ID, bc)

Hello @kbar,

in case you are interested in it for academic purposes or someone else is, here is a full example for how to use some stuff within the maxon::StreamConversions namespace.

I included examples for hashing, encrypting, and compressing inputs. The example also reverses the operation for compression and encryption. This might be helpful, because there is a bug in the Stream Conversions Manual AES encryption example code, which cause the code to fail due to not filling up the plain text message to the correct block size. There are also some minor bits and bobs which might not be obvious.

I have reached out to the developers about some problems of mine regarding the example code in the docs (which was provided by them, not us) and how Cinema deals with the term block size in the context of AES encryptions. My variant does run and does what I would expect it to do. I will report back here if there are any relevant updates (which I would not anticipate being the case).

Cheers,
Ferdinand

The output:

Password: wubba lubba dub-dub, Secret: d7a2f8231c17aabc885683fb4781a648

Content: Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd  guber, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum.

Encrypted content: {0,0,3,22,120,-38,-43,-110,49,110,3,49,12,4,-65,-78,15,48,-18,15,-23,-35,-27,5,60,-119,56,48,-106,-60,-117,72,30,-32,-33,-121,118,82,36,-123,-35,-91,112,-53,37,119,23,3,-98,117,114,-121,-20,22,29,85,-101,78,-104,56,-88,-77,-97,80,116,24,59,123,-28,-112,106,-18,20,25,27,-72,-119,-49,19,-116,43,-86,80,-57,-48,17,-3,10,-106,-39,-75,-62,-71,-17,105,34,-29,-112,26,-61,17,-114,70,107,-122,-128,-3,59,-128,-47,105,27,4,106,-14,25,-41,52,-32,73,-2,-53,-17,-48,22,-69,7,45,120,115,28,60,21,-84,118,-69,-90,82,-62,110,-5,-114,-113,48,87,-44,-48,31,-53,-69,-50,-124,-55,107,-12,5,-17,89,26,37,123,18,46,100,21,-40,98,-27,-20,60,52,99,8,78,23,-23,-108,-94,-47,40,30,121,108,-114,-13,67,16,-53,19,-19,15,-92,23,36,115,7,-77,77,30,-1,14,-25,-91,62,-24,11,106,-106,31,-35,0,94,-62,-56,-61,-127,58,-108,-54,89,-93,-64,10,-42}

Decrypted content: Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd  guber, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum.

The code:

// Example for a maxon API conformant implementation to encrypt and compress text data.            
// 
// This mostly showcases the maxon::StreamConversions namespace which contains operations for
// streams of data, not just text. The example showcases the three important functionalities of
// compression, encryption and hashing of StreamConversions.
// 
// This will effectively take an input string and compress and then encrypt it, and after that
// reverse the operation. I deliberately left out file operations here, to make this a bit more
// streamlined. File operations would have to be done with maxon::BaseStreamInterface types (in-
// and output streams) within the maxon API.
// 
// As discussed in:
//     https://plugincafe.maxon.net/topic/13449

#include "c4d.h"
#include "c4d_symbols.h"
#include "maxon/cryptography.h"
#include "maxon/cryptography_hash.h"
#include "maxon/datacompression.h"
#include "maxon/iostreams.h"
#include "maxon/secure_random.h"
#include "maxon/streamconversion.h"

/// -----------------------------------------------------------------------------------------------
/// Hashes a password into a 32 characters secret.
/// 
/// Could also be done with maxon::GetPasswordHash() and maxon::HashPasswordWithSalt() in a more
/// convenient form.
/// 
/// @param[in] password The password to hash.
/// @return The hashed password.
/// -----------------------------------------------------------------------------------------------
maxon::Result<maxon::String>GetAES128Secret(const maxon::String password)
{
  iferr_scope;

  // The input password and a temporary hash result as arrays.
  const maxon::BaseArray<maxon::Char> secret = password.GetCString() iferr_return;
  maxon::BaseArray<maxon::UChar> hash;

  // Use the StreamConverions MD5 hash to hash the password into a 32 characters secret. 
  const maxon::StreamConversionRef md5 = maxon::StreamConversions::HashMD5().Create() iferr_return;
  md5.ConvertAll(secret, hash) iferr_return;
  // Get the hash as a hex string.
  const maxon::String result = maxon::GetHashString(hash) iferr_return;

  return result;
}

/// -----------------------------------------------------------------------------------------------
/// Compresses and encrypts an input string.
/// 
/// @param[in] content The input text to compress and encrypt.
/// @param[in] secret The encryption secret.
/// @return The compressed and encrypted content as a char array.
/// -----------------------------------------------------------------------------------------------
maxon::Result<maxon::BaseArray<maxon::Char>>GetEncrypted(
  const maxon::String content,const maxon::String secret)
{
  iferr_scope;

  // The in- and output as char arrays.
  maxon::BaseArray<maxon::Char> plaintextContent = content.GetCString() iferr_return;
  maxon::BaseArray<maxon::Char> encryptedContent;

  // The compression settings, the compression rate can lie between 0 and 9, where 9 is the
  // strongest (and slowest) compression.
  maxon::DataDictionary settings;
  settings.Set(maxon::STREAMCONVERSION::ZIP::ENCODER::COMPRESSION, maxon::Int(9)) iferr_return;
  settings.Set(maxon::STREAMCONVERSION::ZIP::ENCODER::WRITESIZE, true) iferr_return;

  // Build a CryptoKey for an AES encryption.
  const maxon::Id encoderID = maxon::StreamConversions::AesEncoder.GetId();
  const maxon::Int blockSize = 128;
  const maxon::Int keySize = 128;
  const maxon::BaseArray<maxon::Char> key = secret.GetCString() iferr_return;
  const maxon::CryptoKey cryptoKey (encoderID, blockSize, key.GetFirst(), keySize);
  maxon::DataDictionary cryptoSettings;
  cryptoSettings.Set(maxon::CryptographyOptions::CRYPTOKEY, cryptoKey) iferr_return;

  // We can either compress first and then encrypt the data or do it the other way around. I did 
  // choose to compress first, since trying to decompress data first is relatively common attack
  // pattern. Encrypting first and then compressing might yield more favorable compression rates. 
  // This will be most impactful when the plain text is relatively small, due to us filling 
  // up the plain text message up to the AES encryption block size further down below. So, if the 
  // compressed message happens to be 17 bytes long, the code below will fill it up to 32 bytes.
  // If we compress after encrypting, we will also compress that "filling up". But since the 
  // maximum overhead due to this is 15 bytes, it can be ignored IMHO.
  const maxon::StreamConversionRef zipEncoder = 
    maxon::StreamConversions::ZipEncoder().Create(settings) iferr_return;
  zipEncoder.ConvertAll(plaintextContent, encryptedContent) iferr_return;

  // Make sure the compressed data is null terminated. We are going to have to fill up this data to
  // the fixed block size of an AES encryption. And we are going to use this null as a marker when
  // we later decrypt the data and then have to separate the message from the "fill-up"-content.
  encryptedContent.Append(0) iferr_return;

  // Setup an AES encoder.
  const maxon::StreamConversionRef aesEncoder = 
    maxon::StreamConversions::AesEncoder().Create(cryptoSettings) iferr_return;

  // Determine if the data does match the fixed block size (128 bits) of an AES encryption.
  const maxon::Int initialSize = encryptedContent.GetCount();
  const maxon::Int aesBlockSize = aesEncoder.GetBlockSize();
  const maxon::Int targetSize = (((8 * initialSize) / blockSize) + 1) * aesBlockSize;
  const maxon::Int diff = targetSize - initialSize;

  // Fill the difference of the data to the block size stride with random bits/bytes.
  if (diff > 0)
  {
    encryptedContent.Resize(targetSize) iferr_return;

    maxon::UChar* randomDataStart = (maxon::UChar*)(encryptedContent.GetFirst()) + initialSize;
    const maxon::Int randomDataSize = diff;
    const auto randomDataBlock = maxon::ToBlock<maxon::UChar>(randomDataStart, randomDataSize);
    const maxon::SecureRandomProvider provider = maxon::SecureRandom::GetDefaultProvider();
    maxon::SecureRandom::GetRandomNumber(provider, randomDataBlock);
  }

  // Check if the encoder does support in place conversions.
  if (!aesEncoder.SupportInplaceConversion())
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);
  // Encrypt the data in place.
  aesEncoder.ConvertAllInplace(encryptedContent) iferr_return;
  
  return encryptedContent;
}

/// -----------------------------------------------------------------------------------------------
/// Decrypts and decompresses a message that has been encoded with GetEncrypted().
/// 
/// @param[in] content The input text to decompress and decrypt.
/// @param[in] secret The encryption secret.
/// @return The decompressed and decrypted content as a string.
/// -----------------------------------------------------------------------------------------------
static maxon::Result<maxon::String>GetDecrypted(
   const maxon::BaseArray<maxon::Char>& encryptedContent, const maxon::String secret)
{
  iferr_scope;

  // The compression settings, the compression rate can lie between 0 and 9, where 9 is the
  // strongest (and slowest) compression.
  maxon::DataDictionary settings;
  settings.Set(maxon::STREAMCONVERSION::ZIP::ENCODER::COMPRESSION, maxon::Int(9)) iferr_return;
  settings.Set(maxon::STREAMCONVERSION::ZIP::ENCODER::WRITESIZE, true) iferr_return;

  // Build a CryptoKey for an AES encryption.
  const maxon::Id encoderID = maxon::StreamConversions::AesEncoder.GetId();
  const maxon::Int blockSize = 128;
  const maxon::Int keySize = 128;
  maxon::BaseArray<maxon::Char> key = secret.GetCString() iferr_return;
  const maxon::CryptoKey cryptoKey(encoderID, blockSize, key.GetFirst(), keySize);

  // Setup an AES decoder.
  maxon::DataDictionary cryptoSettings;
  cryptoSettings.Set(maxon::CryptographyOptions::CRYPTOKEY, cryptoKey) iferr_return;
  const maxon::StreamConversionRef aesDecoder = 
    maxon::StreamConversions::AesDecoder().Create(cryptoSettings) iferr_return;

  // Check if decoder supports in place conversions.
  if (!aesDecoder.SupportInplaceConversion())
    return maxon::UnexpectedError(MAXON_SOURCE_LOCATION);

  // Decrypt the message in place.
  aesDecoder.ConvertAllInplace(encryptedContent) iferr_return;

  // Decompress the data up to the null termination within the decrypted message now written into
  // encryptedContent.
  maxon::BaseArray<maxon::Char> decompressed;
  const maxon::StreamConversionRef zipDecoder = 
    maxon::StreamConversions::ZipDecoder().Create(settings) iferr_return;
  zipDecoder.ConvertAll(encryptedContent, decompressed) iferr_return;

  return maxon::String (decompressed);
}

/// -----------------------------------------------------------------------------------------------
/// Runs the example.
/// 
/// @param doc Not needed, requirement of private interface.
/// -----------------------------------------------------------------------------------------------
static maxon::Result<void> RunExample(BaseDocument* doc)
{
  iferr_scope;

  //The password and some mock data to encrypt.
  const maxon::String password = "wubba lubba dub-dub"_s;
  const maxon::Char* content = "Lorem ipsum dolor sit amet, consetetur sadipscing elitr, "
    "sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam "
    "voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd  "
    "guber, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, "
    "consetetur elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna "
    "aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. "
    "Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem "
    "ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt "
    "ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo "
    "duo dolores et ea rebum.";
  const maxon::String inputContent (content);

  // Variables for the encrypted & decrypted content and secret.
  maxon::BaseArray<maxon::Char> encryptedContent;
  maxon::String decryptedContent, secret;

  // Hash the password.
  iferr(secret = GetAES128Secret(password))
    ApplicationOutput("Failed to hash password.");

  // Compress and encrypt the content.
  iferr (encryptedContent = GetEncrypted(inputContent, secret))
    ApplicationOutput("Failed to encrypt data.");

  // Decrypt and decompress the content.
  iferr(decryptedContent = GetDecrypted(encryptedContent, secret))
    ApplicationOutput("Failed to decrypt data.");

  ApplicationOutput("Password: @, Secret: @", password, secret);
  ApplicationOutput("Content: @", inputContent);
  ApplicationOutput("Encrypted content: @", encryptedContent);
  ApplicationOutput("Decrypted content: @", decryptedContent);

  return maxon::OK;
}

Hi @orestiskon,

thank you for flagging the topic as answered.

Cheers,
Ferdinand

Hello @mari,

When I looked at Maxon's official website, I found a description that could create "Hallo CommandData!", But I couldn't find this window myself. Is there a window in which you can create a program?

I assume with that you mean that you want to know how to create a sub-menu entry for your plugin in the "Extensions" menu of the main menu of Cinema 4D, right? Cinema does this sort of automatically. As soon as Cinema does encounter a directory which contains more than one plugin definition in a subdirectory in one of the plugin paths specified by the user, Cinema will wrap all the plugins defined there in a sub menu named after the directory these plugin definitions are contained in. So, as shown below, if you create a directory "My Fancy Plugin Collection" in one of the plugin search paths, and then put two plugin definitions, either in one or in multiple files, into this directory, Cinema will wrap all plugins there within a s sub-menu called "My Fancy Plugin Collection".

Is there a rule for plug-in ID? What number or later should be used, etc ...

Plugin IDs have to be regsitered here on Plgin Café with the plugin id generator.

Cheers,
Ferdinand

Hello @orestiskon,

without any further replies or questions, we will consider this thread as solved by Thursday and flag it accordingly.

Thank you for your understanding,
Ferdinand