Posts made by m_adam

@mikeudin said in Custom FIELDLAYER_CHANNELFLAG:

We need use different values, which user can disable/enable as color, value, direction and rotation native field flags.
In other words, we need to change several plugin parameters using only one FieldList. So instead color, value, direction and rotation flags we need something like value1, value2, value3 flags.

Hi @mikeudin
Unfortunately, there is no way to add additional channels to the overall field system, only the pre-build one can be used.
So if you have 3 values, you will need 3 fieldList.

@SolarPH said in Python NODES - Shouldn't really they can change the scene?:

Also, Anyone know how to extract Thread Name? Or if possible, a list of Thread ID with their thread name would be useful.

The Cinema 4d SDK offers no way to retrieve a list of all running threads, and thread doesn't have a name.

Also, I wonder if procesisng the threads can have a delay using a timer thing...

I'm not sure to understand what do you mean. In Python and in general, the SDK offers no means to interact with other threads.

In the end, the only proper way is to create a MessageData plugin to react to a Core Event and do the stuff within this MessageData plugin.

Cheers,
Maxime.

Looking at the doc in R19:

So I'm afraid there is no simple solution that will work on each version maxon::String being introduced in R20, you will need to adapt your code.

Cheers,
Maxime.

An express tag is a tag, and it evaluation takes place as any other tag, meaning it has the same limitation as a Python Scripting Tag.

@SolarPH said in Python NODES - Shouldn't really they can change the scene?:

I've set all of those outside Execute method to ensure that it wouldn't loop infinitely. I often connect it to an if/else statement (connected to a boolean/integer switch that switches itself off after the first cycle) to ensure that it wouldn't make Cinema4D crash.

I'm not sure to follow you here but since you modify the scene content while the scene execution (aka xpresso execution) then it can affect the stability, and it does not matter if it's executed once or 100 times, so you may run into a conflict with another part of the scene while this other part is accessed by something else, and you have a crash.

make sure to call StopAllThread, but you can even call EventAdd

I actually haven't tested StopAllThread line yet, but I can already use EventAdd() after any commands that changes the scene in terms of heirarchy and inserted objects. I haven't really tested doing a delete command, but I have some ways to let the code know what to delete after the cycle. Utilizng ports as a way to actually pass the correct object data on the code makes it easier for me to execute this kinds of codes on my python tags.

I was speaking if you are in the main thread, which is not the case here because you are in a tag execution, so if you call StopAllThread within your thread, your thread will be canceled (due to the nature of python, your python code may execute completely but not the other part of the xpresso evaluation)

Also, According to the online manual about python codes for cinema4d (official documentation), for example, I do

c4d.documents.MergeDocument(doc,Path,c4d.SCENEFILTER_OBJECTS|c4d.SCENEFILTER_MATERIALS,None)

will make it run on Main C4D Thread (i don't actually know if not putting the None at the end of the code makes it run on another thread, but when I tried, it doesn't actually crash C4D since the line only runs once because of the nature of the switch I used)

Passing None in the MergeDocument will not make it run into the main thread, you just pass the thread you are currently in, and it will be this thread that will be tested if you should leave or not, but it does not modify where the code is executed. So calling MergeDocument is not fine because, in the end, you modify the current document especially if there are some materials. And this could make Cinema 4D Crash since a lot of stuff happens during a merge.

Cheers,
Maxime.

Hi, I can confirm there is no way exposed to 3rd party developers to set manually the 2D/3D track Data.

Cheers,
Maxime.

This does not solve your initial issue since it requires the use of GetItemDim and it was introduced in R18 but here is how to avoid your second issue:

import c4d

class Dialog(c4d.gui.GeDialog):
    
    def CreateLayout(self):
        bc = c4d.BaseContainer()
        bc.SetBool(c4d.BITMAPBUTTON_BUTTON, True)
        bc.SetInt32(c4d.BITMAPBUTTON_ICONID1, c4d.Ocube)
        bc.SetInt32(c4d.BITMAPBUTTON_FORCE_SIZE, 32)
        button = self.AddCustomGui(10003, c4d.CUSTOMGUI_BITMAPBUTTON, "but", c4d.BFH_SCALEFIT | c4d.BFV_SCALEFIT, 40, 40, bc)
        button.SetCommandDragId(c4d.Ocube)
        self.AddStaticText(10001, 0, 0, name="test")
        return True

    def IsPositionOnGadget(self, gadgetId, x, y):
        # Be sure that the windows is opened,
        # in our case since we call it in BFM_INTERACTSTART it's ok
        buttonData = self.GetItemDim(gadgetId)
        
        if not buttonData["x"] < x < buttonData["x"] + buttonData["w"]:
            return False

        if not buttonData["y"] < y < buttonData["y"] + buttonData["h"]:
            return False

        return True

    def Message(self, msg, result):
        # Main thread
        if msg.GetId() == c4d.BFM_INTERACTSTART:
            c4d.StopAllThreads()

            # Check the mouse is clicked
            state = c4d.BaseContainer()
            self.GetInputState(c4d.BFM_INPUT_MOUSE, c4d.BFM_INPUT_MOUSERIGHT, state)

            if state.GetInt32(c4d.BFM_INPUT_CHANNEL) != 0:

                # Get coordinates
                x = state.GetInt32(c4d.BFM_INPUT_X)
                y = state.GetInt32(c4d.BFM_INPUT_Y)
                g2l  = self.Global2Local() 
                x += g2l['x']  
                y += g2l['y']

                # Checks the coordinate is within the range of the BitmapButton
                if self.IsPositionOnGadget(10003, x, y):
                    print 'Icon clicked in the GeDialog.'

                    # Stop others event to be processed
                    self.KillEvents()
                    return True
                
        return c4d.gui.GeDialog.Message(self, msg, result)

# Main function
def main():
    global dlg
    dlg = Dialog()
    dlg.Open(c4d.DLG_TYPE_ASYNC)

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

Note that there is a very similar problem Disable default Right-Click Menu that you may found interesting about how to handle popup in your dialog.

And adding this constraint in mind, I'm afraid I don't see any solution to make it work before R18.
Cheers,
Maxime.

Hi @pyxelrigger thanks for reaching us, the main issue is to properly update you need to send the message MSG_DESCRIPTION_COMMAND and this is what the UI, it set the parameter then call this message.

But adding this call in the execute method of the python tag is not enough.
This message is processed by the constraint tag and add an Undo, and as said multiple time, this is not possible to add an undo in a threaded environment(see Python Tags - Shouldn't really they can change the scene? so this fail.

So the workaround is to not call the message during the scene execution of the scene but when the value is set in the user Data, so you react to a GUI interaction (main thread) so you are free to do what you want.

import c4d
#Welcome to the world of Python

def message(msgId, msgData):
    # React to the change within the UI, since it came from the UI, this is executed in the Main Thread, so you can add Undo or Add Event
    if msgId == c4d.MSG_DESCRIPTION_POSTSETPARAMETER:
        # Check if its an User Data ID
        if msgData['descid'].IsPartOf(c4d.DESCID_DYNAMICSUB):
            # Checks if its the User Data ID 1 that changed
            if msgData['descid'][-1].id == 1:
                constraintTag = op.GetObject().GetTag(1019364)

                # This will update the stuff and create an Undo
                constraintTag.Message(c4d.MSG_DESCRIPTION_COMMAND, {"id": c4d.ID_CA_CONSTRAINT_TAG_PARENT_LOCALTRANFORM_UPDATEBUTTON})
                c4d.EventAdd()
        return True

def main():
    option = op[c4d.ID_USERDATA,1]
    constraintTag = op.GetObject().GetTag(1019364)
    # Defines the new value (We could do it as well in the message method, but just to show you that Execute is called before)
    constraintTag[c4d.ID_CA_CONSTRAINT_TAG_PARENT_LOCALTRANFORM_UPDATEBUTTON] = option + 1

test_scene.c4d
Cheers,
Maxime.

Hi @SolarPH when you say -- Import Rig Parts > Arrange Parts > Modify UserData > Delete Importer --
it looks like these steps can come from a series of buttons pressed.
If its the case then you react to the message method and in this case, since the initial caller is a GUI interaction this comes from the main thread. And if you are in the main thread you are safe to do whatever you want (make sure to call StopAllThread, but you can even call EventAdd)

If you are doing all of that in the Execute method, then it's not ok and it could affect the c4d stability (we do have crash reports about that).
The main method of the python tag is just the method called during the Execute method of the C++ Python TagData. So that means this execution is done in a threaded environment, see Threading Information.
The whole scene execution is multithreaded, so if you modify this scene while you are in this scene execution the best case it will work because you modify something that will be evaluated after, in the wrong case you will make the change but nothing happens (because the object cache is already evaluated and you do your stuff afterward) or in the worst case, it will crash due to the threading environment you modify and object that is currently accessed in another thread.

Hi sorry to jump on this topic so late, and I agree that if you could do what you want in a Python Scripting tag its preferred, the mains issue with xpresso is that its a whole system that assumes certain things and was really not designed to be embedded within a generator.

So the issue about the AddNode, not working is because user data things, as an object xpresso node, is something dynamic (they will change according to the linked object) and I found no way except via the UI (by asking a UI Redraw or a whole scene execution) to refresh these data so the GvPort can be created.

But since you are in a Generator you don't have access to the GUI since all GUI operation should be done in the Main thread see Threading Information.

Cheers,
Maxime.

Just to add on top,
os.path.listdir and os.path.join in python 2 are context-specific, so if you input a Unicode string it will output a Unicode string, if you input a regular string it will output a regular string.
Now the culprit is on c4d.documents.MergeDocument because normally this method accepts a C++ Filename object (which is the Classic API that under the hood uses the new MaxonAPI maxon::Url). Unfortunately, the Python parser is not able to convert from a Python Unicode string to a C++ Filename, but only from a Python ASCII string to a filename.

So indeed casting from Unicode string to ASCII is the solution.
Cheers,
Maxime.

Hi the color used is:

So is it normal it's not the same on mac and windows, I guess yes, but I will ask design team.
And I can confirm except changing this value there is no way to apply another color.

Cheers,
Maxime.

While the method provided by Zipit Is fine, it is not 100% reliable.

here how to achieve, unfortunately, the ELEMENT_Count value is hardcoded and no way for you to retrieve it.

    constraintTag = doc.GetActiveTag()
    targetCount = constraintTag[c4d.ID_CA_CONSTRAINT_TAG_PARENT_TARGET_COUNT]
    for i in range(targetCount):
        CONSTRAINT_ELEMENT = 10  # This is hardcoded
        targetId = c4d.ID_CA_CONSTRAINT_TAG_PARENT_TARGET_COUNT + i * CONSTRAINT_ELEMENT + 1
        print(constraintTag[targetId])

Cheers,
Maxime.

This is part of the R15 transition Change in R15, more information on
Debugging - Conversion To String and String - Creation Manual.

And you are looking for maxon::FormatString

Cheers,
Maxime

Use maxon::String

Hi @lasselauch there is actually no plan to update ResEdit.

There is the R20 Resource Editor but for the moment it's only for Node stuff.

Cheers,
Maxime.

Hi Pim I would really recommend you reading about Changes in R20, then there is the API Transition and finally the whole Error System.

Now regarding your errors about member "Maxon::ClassInterface::Ref" and explicit type is missing, are they present all the time but they disappear when you build or you also got them during the compilation?

If you got them all the time its an issue within Visual Studio not being able to see automatically generated code, but normally at compile time you should have no issue at all.
Cheers,
Maxime.

Yes unfortunately for the moment manual exists only in C++. There are only a few in Python.

I'm not sure to fully understand "from having a few more examples of the code being used in the context" what do you mean in context? Keep in mind that you have an issue but other people have different issues regarding the same topics so having an example for each possible scenario is almost impossible (or you will never need to develop ;)).

But if you have a feeling an example about XYZ is missing please ask for it by either posting here, create a new topic or create a new GitHub issue.

Cheers,
Maxime

@moGRR said in Python Generator - Adding Shaders to Deformer Objects:

Thanks @PluginStudent - that's working now.

Just so you know that I wasn't being lazy, I did look at the linked manual and the GitHub link, I just sometimes find them hard to follow as I'm not a coder.

Thanks again for your help
Jamie

What did you don't understand?
and how could we improve them in your opinion?

Cheers,
Maxime

Hi Pim sorry for the late reply, this is possible by using the lib_py.h (typically this is somehow what we used before R20 to expose feature in python, but it's way elder, not everything is possible to do, you have less control than with the new python.framework, and the lib_py.h is not maintained (so don't expect any enhancement in it) Only the python.framework will be enhanced.

// Init Python
GePython pythonScope;
pythonScope.Init();

// Acquiere the GIL
GePythonGIL gil_state;

pythonScope.SetNode("doc", doc);
// If doc->GetFirstObject() is nullptr, op variable will not be declared in the python scope, and you cant add a None.
pythonScope.SetNode("op", doc->GetFirstObject());

maxon::String pythonCode = "\
import c4d\n\
\n\
def main():\n\
    print(doc, op)\n\
\n\
if __name__ == '__main__' :\n\
    main()\n\
"_s;

StopAllThreads();
pythonScope.Run(pythonCode);

Cheers,
Maxime.

Hi, Noseman find in the attached scene an example of how to make it work.
The main issue is Python GvNode is not designed to work as an iteration node since internally the Python Xpresso node is not registered with the GV_OPERATORFLAG_ITERATOR.

To work around the issue you could expose an InExcludeData (aka list of objects for Cinema 4D user, this is what you find in the light to include or exclude light). Then process this InExcludeData with standard Xpresso tool.

iterate_hierarchy_xpresso.c4d

Cheers,
Maxime.