It must be the geometry, but I can't figure out what it is about this geometry that's problematic. Since I've switched to using SendModelingCommand on individual objects instead of a full list I have a bit more visibility into the objects that are failing. However, the 4 pieces that MCOMMAND_ALIGNNORMALS consistently fails on don't have much in common.

To be clear, the failure does not produce an error. I've also tried running the plugin with g_console=true and there are no errors or warnings produced. SendModelingCommand simply returns False and the normals are not aligned.

I'll work on collecting the scene and WIP plugin for your perusal.

@zipit There is no imported geometry. The geometry was created in Cinema 4D and has no user normals. However, it looks like you're correct that it's not an issue of non-manifold geometry as the operations still fail if I remove the unnecessary polygons.

It looks like Reverse Normals will fail on an open mesh if a polygon selection is not provided (which seems strange) but my plugin is only attempting it on closed meshes and it still fails.

My workaround for the time being is to call SendModelingCommand() individually for each polygonal object which I'm sure is adding a fair amount of overhead but it's not unbearably slow so I'm going to leave it be for now. If anyone has any other ideas about why these commands might fail I'm all ears!

Quick update: I've copied all of the polygonal objects out of the source document for testing. The first thing I tried was selecting all of the objects and running Align Normals and Reverse Normals from the menu.

The commands do not complete successfully. It seems that there's something about these objects that these commands don't like. Perhaps there's a single non-manifold object hiding in the bunch that is causing the operation to fail for all of them? If that's the case then I feel it might be more worthwhile for Cinema 4D to complete the commands on those objects that it can and print a warning to the console for those that it cannot.

I'm wracking my brain now for methods to manually remove non-manifold surfaces from the list of polygonal objects. I've had very mixed results in the past trying to use python to access information from Mesh Check. I suppose the alternative would be checking the structure of the objects myself to make sure that no edge is shared by more than 2 polygons?

Any ideas out there?

As part of my quest to improve the FBX export of Cinema 4D I've been asked to do some automatic cleanup of meshes before the export.

I'm using several calls of SendModelingCommand() to perform these clean up operations. The requested commands are:

c4d.MCOMMAND_OPTIMIZE
c4d.MCOMMAND_ALIGNNORMALS
c4d.MCOMMAND_REVERSENORMALS

Optimize and Align Normals are run on every polygonal object as checked with IsInstanceOf(c4d.Opolygon). Reverse Normals is run selectively only on meshes with no boundary edges (i.e. closed meshes) whose normals are pointing inward. I can get all of these to work properly in simple test documents, but when I test it with a full fledged production scene the c4d.MCOMMAND_ALIGNNORMALS and c4d.MCOMMAND_REVERSENORMALS calls fail and SendModelingCommand() returns False. Is there anyway to get more information about why SendModelingCommand() is failing?

Here's the applicable part of my code:

if self.align:
    poly_objs = [o for o in self._GetAllObjects(self.doc.GetFirstObject()) if o.IsInstanceOf(c4d.Opolygon)]
    c4d.StopAllThreads() #Not sure if this is necessary
    res = c4d.utils.SendModelingCommand(c4d.MCOMMAND_ALIGNNORMALS, poly_objs, doc=self.doc) #Align normals for all polygon objects
    if res:
        print("Successfully aligned normals.") #Works in simple scenes
    else:
        print("Could not align normals.") #Doesn't work in production scenes
            
    if self.reverse:
        closed_objs = [o for o in poly_objs if self._IsClosedMesh(o)]
        reversed_objs = [o for o in closed_objs if self._IsReversed(o)]
        c4d.StopAllThreads()
        res = c4d.utils.SendModelingCommand(c4d.MCOMMAND_REVERSENORMALS, reversed_objs, doc=self.doc) #Reverse the normals of all closed polygon objects whose normals are currently reversed
        if res:
            print("Successfully fixed reversed normals.") #Works in simple scenes
        else:
            print("Could not fix reversed normals.") #Doesn't work in production scenes


if self.optimize:
    poly_objs = [o for o in self._GetAllObjects(self.doc.GetFirstObject()) if o.IsInstanceOf(c4d.Opolygon)]
    tool_bc = c4d.BaseContainer()
    tool_bc[c4d.MDATA_OPTIMIZE_UNUSEDPOINTS] = True
    c4d.StopAllThreads()
    res = c4d.utils.SendModelingCommand(c4d.MCOMMAND_OPTIMIZE, poly_objs, bc=tool_bc, doc=self.doc) #Optimize unused points for all polygon objects
    if res:
        print("Successfully removed unused points.") #This one works in production scenes too! For some reason?
    else:
        print("Could not remove unused points.")

Edit: there are 1200 or so polygonal objects in the production scene, only 3 of them are closed meshes with reversed normals. I doubt it's an issue of list length. Many of the polygonal objects are children of generators (Symmetry, Cloner, Subdivision Surface) but I can't imagine that should make a difference.

Just wanted to provide an update here.

I stand corrected, the above plugin creates an FBX that works perfectly when imported into Maya. It appears that Cinema 4D isn't able to understand what's going on in the FBX and I was checking the export by importing into Cinema 4D.

I suppose the lesson here is to follow the actual pipeline when testing

...and the other lesson is that Cinema's FBX export and import are not to be trusted

Hello! I'm attempting to make Cinema 4D's FBX export a bit more robust for our pipeline. We're dealing with lots of instancing of non-polygonal objects which C4D seems to have trouble outputting to FBX. Specifically we're seeing issues with Symmetry, Cloners and Subdivision Surfaces.

I wrote a script that worked well, but it would modify the current document and I felt it would be better to modify a clone of the document. In order to do that I built a class to handle the document preparation. Unfortunately, this seems to have broken something fundamental in the logic but I can't figure out why.

The plugin is supposed to find all instanced subdivision surfaces, create a group null below the subdivision, point all instances that had previously referred to the sds to that null, and then place each of the instances into a new subdivision surface (so that the instance is now the cage mesh). This is the only way I can find to get instances and subdivision surfaces to work together in an FBX export. However, in it's new form the plugin seems to end up with the instances inside of two nulls instead of inside a single subdivision surface. In addition some of the instances and subdivision surfaces are switching locations in the hierarchy. It's a mess!

Perhaps I've bitten off more than I can handle at the moment. Below is my full code. Any help with cleaning this up would be much appreciated!

import c4d
import c4d.utils
import os
import os.path

blacklist = {"persp","top","side","front"}
FBX_EXPORTER_ID = 1026370
PLUGIN_ID = 1053631

class ExportFBX():
    def __init__(self, doc, flags):
        if doc:
            self.doc = doc.GetClone()
            self.name = os.path.splitext(doc.GetDocumentName())[0]
        self.flags = flags
        self.status = False

    def __del__(self):
        if self.doc:
            c4d.documents.KillDocument(self.doc)

    def _GetAllObjects(self, obj):
        while obj:
            yield obj
            for o in self._GetAllObjects(obj.GetDown()):
                yield o
            obj = obj.GetNext()

    def _UpdateName(self, obj):
        name = obj.GetName()
        if name in blacklist:
            obj.SetName("{}_geo".format(name))

    def _UpdateAxis(self, obj):
        if obj:
            null = c4d.BaseObject(c4d.Onull)
            null.SetName("{}_grp".format(obj.GetName()))
            self.doc.InsertObject(null)
            null.InsertBefore(obj)
            obj.InsertUnder(null)
            return null

    def _UpdateSdsInstance(self, obj):
        sds = obj.GetReferenceObject(self.doc)
        parent = None
        child = sds.GetDown()
        pred = obj.GetPred()
        if not pred:
            parent = obj.GetUp()

        obj.SetReferenceObject(child)

        new_sds = c4d.BaseObject(c4d.Osds)
        if sds.GetName().startswith("Subdivision"):
            new_sds.SetName("{0}_subdivision".format(child.GetName()))
        else:
            new_sds.SetName(sds.GetName())

        new_sds.SetData(sds.GetData())
        self.doc.InsertObject(new_sds, parent, pred, checknames=True)
        obj.InsertUnder(new_sds)


    def Prepare(self):
        if self.doc:
            objs = list(self._GetAllObjects(self.doc.GetFirstObject()))
            instances = [o for o in objs if o.IsInstanceOf(c4d.Oinstance)]
            instance_sources = [i.GetReferenceObject(self.doc) for i in instances]
            sds_list = [o for o in objs if o.IsInstanceOf(c4d.Osds) and o in instance_sources]
            convert_editable = [o for o in objs if o.IsInstanceOf(c4d.Osymmetry) or o.IsInstanceOf(1018544)]
            c4d.StopAllThreads()
            c4d.utils.SendModelingCommand(c4d.MCOMMAND_MAKEEDITABLE, convert_editable, doc=self.doc, flags=c4d.MODELINGCOMMANDFLAGS_CREATEUNDO)
            _ = [self._UpdateName(o) for o in objs]
            _ = [self._UpdateAxis(sds.GetDown()) for sds in sds_list]
            _ = [self._UpdateSdsInstance(i) for sds in sds_list for i in instances if i.GetReferenceObject(self.doc) == sds]

    def Export(self):
        if self.doc:
            self.status = c4d.documents.SaveDocument(self.doc,
                            os.path.join(self.doc.GetDocumentPath(), self.name),
                            self.flags,
                            FBX_EXPORTER_ID)
                            
    def GetStatus(self):
        return self.status


class ExportFBXCommandData(c4d.plugins.CommandData):
    def Execute(self, doc):
        flags = c4d.SAVEDOCUMENTFLAGS_EXPORTDIALOG|c4d.SAVEDOCUMENTFLAGS_DONTADDTORECENTLIST|c4d.SAVEDOCUMENTFLAGS_DIALOGSALLOWED|c4d.SAVEDOCUMENTFLAGS_SAVEAS

        fbx_export = ExportFBX(doc, flags)

        fbx_export.Prepare()
        fbx_export.Export()
        
        return fbx_export.GetStatus()
        

# Execute main()
if __name__=='__main__':
    directory, _ = os.path.split(__file__)
    fn = os.path.join(directory, "res", "export_fbx.tif")

    bmp = c4d.bitmaps.BaseBitmap()
    if bmp is None:
        raise MemoryError("Failed to create a BaseBitmap")

    if bmp.InitWith(fn)[0] != c4d.IMAGERESULT_OK:
        raise MemoryError("Failed to initialize a BaseBitmap")  

    c4d.plugins.RegisterCommandPlugin(id=PLUGIN_ID,
                                        str="Export FBX...",
                                        help="An FBX export with enhanced support for instances.",
                                        info=0,
                                        dat=ExportFBXCommandData(),
                                        icon=bmp)