Hi,

Not quite directly a revision of your code but this should help you get started.

import c4d
from c4d import gui

# Main function
def main():
    cloner = doc.SearchObject("Cloner") # Assuming there is already a Cloner Mograph Object 
    plain_effector = doc.SearchObject("Plain")# Assuming there is already a Plain Effector Object 

    effector_list = c4d.InExcludeData()
    effector_list.InsertObject(plain_effector, 1)

    cloner[c4d.ID_MG_MOTIONGENERATOR_EFFECTORLIST] = effector_list
    c4d.EventAdd()


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

Cinema4D can accommodate plug-ins written in C++ or Python. However, it only accept scripts written in Python.

Probably not that helpful but there is an existing script for the C4D OBJ Sequence Exporter
https://richh.co/c4d-native-obj-sequence-export-no-plugins/

Hi @blieque

You can do is the Basic>Enable Checkbox in every object.
If you drag it to the console, the parameter is [c4d.ID_BASEOBJECT_GENERATOR_FLAG]

Thanks Adam for the confirmation.
I'll just send it for Maxon Suggestion for now.

Thanks!

Thanks @m_adam. Works as expected.
My bad, I was looking at the documentation hierarchy erroneously (i.e c4d > modules > graphview > GvNode)

Just a note: I think the if Multiply: line is supposed to be if isMultiply:.

Thanks again. Have a great day ahead!

Hi @m_adam

Thanks for the patience. Your suggestions and reminders works are greatly appreciated.

I guess the confusion stems mainly on my part because I posted slightly two different codes. You were responding to my initial post but I was thinking with the code from the succeeding post(the one in the rar file). Totally my bad.

Anyhow, here is the working code (using the initial post) which works as I expected:

import c4d

class ColorButton(object):

    def __init__(self):
        self.width = None
        self.height = None
        self.color = None
        self.color = None
        self.btn_id = None
        self.menu_list = None


    def create(self, dlg, w, h, color, btn_id):

        self.width = w
        self.height = h
        self.color = color
        self.btn_id = btn_id

        bmp_color = c4d.bitmaps.BaseBitmap()
        bmp_color.Init(w, h)

        for y in xrange(w):
            for x in xrange(h):
                bmp_color.SetPixel(x, y, color[0], color[1], color[2])

        bcBitmapButton = c4d.BaseContainer()
        bcBitmapButton[c4d.BITMAPBUTTON_BUTTON] = True

        bmp_btn = dlg.AddCustomGui(self.btn_id, c4d.CUSTOMGUI_BITMAPBUTTON, "", c4d.BFH_CENTER | c4d.BFV_CENTER, w, h, bcBitmapButton)

        bmp_btn.SetImage(bmp_color, True)

    def create_menu(self):

        self.menu = c4d.BaseContainer()

        for menu_item in self.menu_list: 
            counter = 0
            IDM_MENU = c4d.FIRST_POPUP_ID + counter
            self.menu.InsData(IDM_MENU, menu_item)

            counter += 1

class MyDialog(c4d.gui.GeDialog):

    def __init__(self):
        self.btn_id_list = []
        self.class_btn_id_dict = {}

    def CreateLayout(self):

        red_button = ColorButton()
        red_button.create(self, w=50,h=50,color=(255,0,0), btn_id=6000)
        red_button.menu_list = ['Menu1', 'Menu2', 'Menu3']
        self.btn_id_list.append(red_button.btn_id)
        self.class_btn_id_dict[6000] = red_button

        blue_button = ColorButton()
        blue_button.create(self, w=50,h=50,color=(0,0,255), btn_id=7000)
        blue_button.menu_list = ['Menu4', 'Menu5', 'Menu6', 'Menu7']
        self.btn_id_list.append(blue_button.btn_id)
        self.class_btn_id_dict[7000] = blue_button


        green_button = ColorButton()
        green_button.create(self, w=50,h=50,color=(0,255,0), btn_id=8000)
        green_button.menu_list = ['Menu8', 'Menu9']
        self.btn_id_list.append(green_button.btn_id)
        self.class_btn_id_dict[8000] = green_button

        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 function_to_determine_gadgetId_under_mouse_cursor(self, x, y):
        for gadgetId in self.btn_id_list:
            if self.IsPositionOnGadget(gadgetId, x, y):
                return gadgetId
            
    def Message(self, msg, result):
        if msg.GetId() == c4d.BFM_ADJUSTSIZE:
          self._x = msg[3] # Retrieve Y size of the GeDialog
          self._y = msg[4] # Retrieve Y size of the GeDialog

        # We are on the main thread here
        elif msg.GetId() == c4d.BFM_INTERACTSTART:
            c4d.StopAllThreads()

            state = c4d.BaseContainer()
            self.GetInputState(c4d.BFM_INPUT_MOUSE, c4d.BFM_INPUT_MOUSERIGHT, state)

            if state.GetInt32(c4d.BFM_INPUT_VALUE) == True:

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

                gadgetId = self.function_to_determine_gadgetId_under_mouse_cursor(x=x,y=y)

                if gadgetId in self.btn_id_list:

                     if self.IsPositionOnGadget(gadgetId=gadgetId, x=x, y=y):

                          button_class = self.class_btn_id_dict[gadgetId] 
                          button_class.create_menu()


                          l2s = self.Local2Screen()
                          print str(x+l2s['x']) + " :: " + str(y+l2s['y'])
                          self.KillEvents()
                          res = c4d.gui.ShowPopupDialog(cd=self, bc=button_class.menu, x=x+l2s['x'], y=y+l2s['y'])
                          return True

        return c4d.gui.GeDialog.Message(self, msg, result)

if __name__ == "__main__":
    dlg = MyDialog()
    dlg.Open(dlgtype=c4d.DLG_TYPE_ASYNC, pluginid=20304050)

@r_gigante

Thanks for the reference.
For anyone trying to achieve the same,
here is a sample file.
https://www.dropbox.com/sh/z1lzyphp8qnt9kw/AAB2P5gNo16IHafgc6xPEsy4a?dl=0

Thanks again for @zipit for the help.

@m_magalhaes @zipit

I managed to flip the mesh (not necessarily a pose morph target since I'd have to know the API).
Anyhow, here is a demo of it working:
https://www.dropbox.com/s/bh4p26s4m9qwljw/c4d272_flip_miror_mesh.mp4?dl=0

Here is wip script. It only works if the x-axis is dead set on 0.
Also, it is slow since it has to loop within a loop.

import c4d
from c4d import gui


# Main function
def main():
    neutral_geo = doc.SearchObject('neutral_geo')
    posed_geo = doc.SearchObject('posed_geo')
    neutral_world_matrix = neutral_geo.GetMg()
    posed_world_matrix = posed_geo.GetMg()
    
    neut_lcl_pnts = neutral_geo.GetAllPoints()
    neut_gbl_pnts = [point * neutral_world_matrix for point in neut_lcl_pnts]
    
    posed_lcl_pnts = posed_geo.GetAllPoints()
    posed_gbl_pnts = [point * posed_world_matrix for point in posed_lcl_pnts]
        
    match_pnts = []
    left_pnts = []
    right_pnts = []
    
    for idx, point in enumerate(neut_gbl_pnts):
        if point[0] == 0.0: # ignore points at the world x axis
            continue
        
        if point[0] > 0.0:
            left_pnts.append((idx,point))
        
        if point[0] < 0.0:
            right_pnts.append((idx,point))
            
    
    for left in left_pnts:
        for right in right_pnts:
            if left[1][1] == right[1][1]: # check if Y pos match
                if left[1][2] == right[1][2]: # check if Z pos match
                   if left[1][0] == -1 * (right[1][0]):# check if X pos are inverse
                       match_pnts.append((left[0],right[0]))
        
        
    for pnt in match_pnts:
        
        reversed_left = posed_lcl_pnts[pnt[1]]
        reversed_left[0] = reversed_left[0] * -1
        reversed_right = posed_lcl_pnts[pnt[0]]
        reversed_right[0] = reversed_right[0] * -1
        
        
        posed_geo.SetPoint(pnt[0], reversed_left)
        posed_geo.SetPoint(pnt[1], reversed_right)
        
    posed_geo.Message(c4d.MSG_UPDATE)
     
    c4d.EventAdd()

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

@m_adam

Thanks for the response.

RE: without enabling the Post Deformers option.
It seems like so. I initially thought I could reverse engineer it by getting the point's skin influence (its joint and its weight) and in a way factor it with the intended world vector. However, I gave up since I realize point can have several joints and several weight. Haha

Don't get me wrong, enabling the post deformer works as expected.
The problem comes because of its inherent nature
"calculate the points position of the morph after they are deformed by a Deformer."

It presupposes that the (near) last deformation comes from the pose morph.
For example, Squash/Stretch>Bulge>Bend>Twist>Pose Morph.
However, there are cases where the intended deformation is
Pose Morph>Squash/Stretch>Bulge>Bend>Twist.

So having the post deformer off while still getting the world position desired gives a bit of flexibility.

Anyhow, thanks again for the help.
I'll just use the post deformer for now and see where I get stuck.

Have a great day ahead!

Thanks for the explanation.

RE: So you want to use it like a file manger
Yep yep. The main reason is we use several software and not only C4D. So having to build an asset system that only reads in C4D is limiting. It's a no go.

Anyway, for those wondering, I found a way with the Megascan's Bridge as it accepts custom asset.

Will close this thread accordingly.

Hi @m_adam

Thanks for the response. Although just a personal sentiment, it is a bit disappointing having to wait 3 years for the actual API only to find out that it will be irrelevant in the next few releases.

Anyhow, will close this thread.

Hi @ferdinand

Sorry for the late response. Sure sure. Let's close this thread.

In the C++ documentation, it says

The NodeMaterial is a temporary class, introduced in order to provide access to the node system. In the future this class will be deprecated, as most of the use cases are covered by the BaseList2D and the maxon::NimbusBaseInterface.

Does this mean if we build our pipeline around this NodeMaterial object all our code will be useless later on?

Why does it have to be temporary? Why not make it permanent? I thought this was already part of the "new" core.

Hi @ferdinand. Thanks for the response

Oh gotcha. So we can access Content Browser through C++? Like select objects in content browser and open it in C4D?

RE: its own container format, i.e., lib4d.
You can view files in content browser with just fbx or obj files. It doesn't have to be in lib4d format.

Hi,

Just to confirm with the new asset browser, API for the content browser is no longer possible?
Is this assessment correct?

What's wrong with the asset browser, it modifies your existing asset to a database format.
It's no go for me.

Regards,
Ben

Gotcha.
Thanks for the response. Will close this thread for now.

Hi,

Any update on this one on the latest release (S24)?

@m_adam

Thanks for confirmation.
Will close this thead now.

Looking forward to the documentation

Any updates on this one?