Best posts made by ferdinand

ferdinand

Hi,

thanks for the kind words both from Maxon and the community. I am looking forward to my upcoming adventures with the SDK Team and Cinema community.

Cheers,
Ferdinand

ferdinand

Hi,

that your script is not working has not anything to do with pseudo decimals, but the fact that you are treating numbers as strings (which is generally a bad idea) in a not very careful manner. When you truncate the string representation of a number which is represented in scientific notation (with an exponent), then you also truncate that exponent and therefor change the value of the number.

To truncate a float you can either take the floor of my_float * 10 ** digits and then divide by 10 ** digits again or use the keyword round.

data = [0.03659665587738824,
        0.00018878623163019122,
        1.1076812650509394e-03,
        1.3882258325566638e-06]

for n in data:
    rounded = round(n, 4)
    floored = int(n * 10000) / 10000
    print(n, rounded, floored)

0.03659665587738824 0.0366 0.0365
0.00018878623163019122 0.0002 0.0001
0.0011076812650509394 0.0011 0.0011
1.3882258325566637e-06 0.0 0.0
[Finished in 0.1s]

Cheers
zipit

ferdinand

Hi,

as @Cairyn said the problem is unreachable code. I also just saw now that you did assign the same ID to all your buttons in your CreateLayout(). Ressource and dialog element IDs should be unique. I would generally recommend to define your dialogs using a resource, but here is an example on how to do it in code.

BUTTON_BASE_ID = 1000
BUTTON_NAMES = ["Button1", "Button2", "Button3", "Button4", "Button5"]
BUTTON_DATA = {BUTTON_BASE_ID + i: name for i, name in enumerate(BUTTON_NAMES)}

class MyDialog(gui.GeDialog):

    def CreateLayout(self):
        """
        """
        self.GroupBegin(id=1013, flags=c4d.BFH_SCALEFIT, cols=5, rows=4)
        for element_id, element_name in BUTTON_DATA.items():
            self.AddButton(element_id, c4d.BFV_MASK, initw=100, 
                           name=element_name)
        self.GroupEnd()
        return True

    def Command(self, id, msg):
        """
        """
        if id == BUTTON_BASE_ID:
            print "First button has been clicked"
        elif id == BUTTON_BASE_ID + 1:
            print "Second button has been clicked"
        # ...
        if id in BUTTON_DATA.keys(): # or just if id in BUTTON_DATA
            self.Close()
        return True

ferdinand

Hi,

sorry for all the confusion. You have to pass actual instances of objects. The following code does what you want (and this time I actually tried it myself ;)).

import c4d

def main():
    """
    """
    bc = doc.GetAllTextures(ar=doc.GetMaterials())
    for cid, value in bc:
        print cid, value

if __name__=='__main__':
   main()

Cheers,
zipit

ferdinand

Hi,

you use GetActiveDocument() in a NodeData environment. You cannot do this, since nodes are also executed when their document is not the active document (while rendering for example - documents get cloned for rendering).

Cheers
zipit

ferdinand

Hi,

you have to invoke AddUserArea and then attach an instance of your implemented type to it. Something like this:

my_user_area = MyUserAreaType()
self.AddUserArea(1000,*other_arguments)
self.AttachUserArea(my_user_area, 1000)

I have attached an example which does some things you are trying to do (rows of things, highlighting stuff, etc.). The gadget is meant to display a list of boolean values and the code is over five years old. I had a rather funny idea of what good Python should look like then and my attempts of documentation were also rather questionable. I just wrapped the gadget into a quick example dialog you could run as a script. I did not maintain the code, so there might be newer and better ways to do things now.

Also a warning: GUI stuff is usually a lot of work and very little reward IMHO.

Cheers
zipit

import c4d
import math
import random

from c4d import gui

# Pattern Gadget
IDC_SELECTLOOP_CELLSIZE = [32, 32]
IDC_SELECTLOOP_GADGET_MINW = 400
IDC_SELECTLOOP_GADGET_MINH = 32

class ExampleDialog(gui.GeDialog):
    """
    """
    def CreateLayout(self):
        """
        """

        self.Pattern = c4d.BaseContainer()
        for i in range(10):
            self.Pattern[i] = random.choice([True, False])
        self.PatternSize = len(self.Pattern)

        self.gadget = Patterngadget(host=self)
        self.AddUserArea(1000, c4d.BFH_FIT, 400, 32)
        self.AttachUserArea(self.gadget, 1000)
        return True

class Patterngadget(gui.GeUserArea):
    """
    A gui gadget to modify and display boolean patterns.
    """

    def __init__(self, host):
        """
        :param host: The hosting BaseToolData instance
        """
        self.Host = host
        self.BorderWidth = None
        self.CellPerColumn = None
        self.CellWidht = IDC_SELECTLOOP_CELLSIZE[0]
        self.CellHeight = IDC_SELECTLOOP_CELLSIZE[1]
        self.Columns = None
        self.Height = None
        self.Width = None
        self.MinHeight = IDC_SELECTLOOP_GADGET_MINH
        self.MinWidht = IDC_SELECTLOOP_GADGET_MINW
        self.MouseX = None
        self.MouseY = None

    """------------------------------------------------------------------------
        Overridden methods
        --------------------------------------------------------------------"""

    def Init(self):
        """
        Init the gadget.
        :return : Bool
        """
        self._get_colors()
        return True

    def GetMinSize(self):
        """
        Resize the gadget
        :return : int, int
        """
        return int(self.MinWidht), int(self.MinHeight)

    def Sized(self, w, h):
        """
        Get the gadgets height and width
        """
        self.Height, self.Width = int(h), int(w)
        self._fit_gadget()

    def Message(self, msg, result):
        """
        Fetch and store mouse over events
        :return : bool
        """
        if msg.GetId() == c4d.BFM_GETCURSORINFO:
            base = self.Local2Screen()
            if base:
                self.MouseX = msg.GetLong(c4d.BFM_DRAG_SCREENX) - base['x']
                self.MouseY = msg.GetLong(c4d.BFM_DRAG_SCREENY) - base['y']
                self.Redraw()
                self.SetTimer(1000)
        return gui.GeUserArea.Message(self, msg, result)

    def InputEvent(self, msg):
        """
        Fetch and store mouse clicks
        :return : bool
        """
        if not isinstance(msg, c4d.BaseContainer):
            return True
        if msg.GetLong(c4d.BFM_INPUT_DEVICE) == c4d.BFM_INPUT_MOUSE:
            if msg.GetLong(c4d.BFM_INPUT_CHANNEL) == c4d.BFM_INPUT_MOUSELEFT:
                base = self.Local2Global()
                if base:
                    x = msg.GetLong(c4d.BFM_INPUT_X) - base['x']
                    y = msg.GetLong(c4d.BFM_INPUT_Y) - base['y']
                    pid = self._get_id(x, y)
                    if pid <= self.Host.PatternSize:
                        self.Host.Pattern[pid] = not self.Host.Pattern[pid]
                        self.Redraw()
        return True

    def Timer(self, msg):
        """
        Timer loop to catch OnMouseExit
        """
        base = self.Local2Global()
        bc = c4d.BaseContainer()
        res = gui.GetInputState(c4d.BFM_INPUT_MOUSE,
                                c4d.BFM_INPUT_MOUSELEFT, bc)
        mx = bc.GetLong(c4d.BFM_INPUT_X) - base['x']
        my = bc.GetLong(c4d.BFM_INPUT_Y) - base['y']
        if res:
            if not (mx >= 0 and mx <= self.Width and
                    my >= 0 and my <= self.Height):
                self.SetTimer(0)
                self.Redraw()

    def DrawMsg(self, x1, y1, x2, y2, msg):
        """
        Draws the gadget
        """
        # double buffering
        self.OffScreenOn(x1, y1, x2, y2)
        # background & border
        self.DrawSetPen(self.ColBackground)
        self.DrawRectangle(x1, y1, x2, y2)
        if self.BorderWidth:
            self.DrawBorder(c4d.BORDER_THIN_IN, x1, y1,
                            self.BorderWidth + 2, y2 - 1)
        # draw pattern
        for pid, state in self.Host.Pattern:
            x, y = self._get_rect(pid)
            self._draw_cell(x, y, state, self._is_focus(x, y))

    """------------------------------------------------------------------------
        Public methods
        --------------------------------------------------------------------"""

    def Update(self, cid=None):
        """
        Update the gadget.
        :param cid: A pattern id to toggle.
        """
        if cid and cid < self.Host.PatternSize:
            self.Host.Pattern[cid] = not self.Host.Pattern[cid]
        self._fit_gadget()
        self.Redraw()

    """------------------------------------------------------------------------
        Private methods
        --------------------------------------------------------------------"""

    def _get_colors(self, force=False):
        """
        Set the drawing colors.
        :return : Bool
        """
        self.ColScale = 1.0 / 255.0
        if self.IsEnabled() or force:
            self.ColBackground = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellActive = c4d.GetViewColor(
                c4d.VIEWCOLOR_ACTIVEPOINT) * 0.9
            self.ColCellFocus = self._get_color_vector(c4d.COLOR_BGFOCUS)
            self.ColCellInactive = self._get_color_vector(c4d.COLOR_BGEDIT)
            self.ColEdgeDark = self._get_color_vector(c4d.COLOR_EDGEDK)
            self.ColEdgeLight = self._get_color_vector(c4d.COLOR_EDGELT)
        else:
            self.ColBackground = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellActive = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellFocus = self._get_color_vector(c4d.COLOR_BG)
            self.ColCellInactive = self._get_color_vector(c4d.COLOR_BG)
            self.ColEdgeDark = self._get_color_vector(c4d.COLOR_EDGEDK)
            self.ColEdgeLight = self._get_color_vector(c4d.COLOR_EDGELT)
        return True

    def _get_cell_pen(self, state, _is_focus):
        """
        Get the color for cell depending on its state.
        :param state   : The state
        :param _is_focus : If the cell is hoovered.
        :return        : c4d.Vector()
        """
        if state:
            pen = self.ColCellActive
        else:
            pen = self.ColCellInactive
        if self.IsEnabled() and _is_focus:
            return (pen + c4d.Vector(2)) * 1/3
        else:
            return pen

    def _draw_cell(self, x, y, state, _is_focus):
        """
        Draws a gadget cell.
        :param x:       local x
        :param y:       local y
        :param state:   On/Off
        :param _is_focus: MouseOver state
        """
        # left and top bright border
        self.DrawSetPen(self.ColEdgeLight)
        self.DrawLine(x, y, x + self.CellWidht, y)
        self.DrawLine(x, y, x, y + self.CellHeight)
        # bottom and right dark border
        self.DrawSetPen(self.ColEdgeDark)
        self.DrawLine(x, y + self.CellHeight - 1, x +
                      self.CellWidht - 1, y + self.CellHeight - 1)
        self.DrawLine(x + self.CellWidht - 1, y, x +
                      self.CellWidht - 1, y + self.CellHeight - 1)
        # cell content
        self.DrawSetPen(self._get_cell_pen(state, _is_focus))
        self.DrawRectangle(x + 1, y + 1, x + self.CellWidht -
                           2, y + self.CellHeight - 2)

    def _get_rect(self, pid, offset=1):
        """
        Get the drawing rect for an array id.
        :param pid    : the pattern id
        :param offset : the pixel border offset
        :return       : int, int
        """
        pid = int(pid)
        col = pid / self.CellPerColumn
        head = pid % self.CellPerColumn
        return self.CellWidht * head + offset, self.CellHeight * col + offset

    def _get_id(self, x, y):
        """
        Get the array id for a coord within the gadget.
        :param x : local x
        :param y : local y
        :return  : int
        """
        col = (y - 1) / self.CellHeight
        head = (x - 1) / self.CellWidht
        return col * self.CellPerColumn + head

    def _is_focus(self, x, y):
        """
        Test if the cell coords are under the cursor.
        :param x : local x
        :param y : local y
        :return  : bool
        """
        if (self.MouseX >= x and self.MouseX <= x + self.CellWidht and
                self.MouseY >= y and self.MouseY <= y + self.CellHeight):
            self.MouseX = c4d.NOTOK
            self.MouseY = c4d.NOTOK
            return True
        else:
            return False

    def _fit_gadget(self):
        """
        Fit the gadget size to the the array
        """
        oldHeight = self.MinHeight
        self.CellPerColumn = int((self.Width - 2) / self.CellWidht)
        self.Columns = math.ceil(
            self.Host.PatternSize / self.CellPerColumn) + 1
        self.MinHeight = int(IDC_SELECTLOOP_GADGET_MINH * self.Columns) + 3
        self.MinWidht = int(IDC_SELECTLOOP_GADGET_MINW)
        self.BorderWidth = self.CellWidht * self.CellPerColumn
        if oldHeight != self.MinHeight:
            self.LayoutChanged()

    def _get_color_vector(self, cid):
        """
        Get a color vector from a color ID.
        :param cid : The color ID
        :return    : c4d.Vector()
        """
        dic = self.GetColorRGB(cid)
        if dic:
            return c4d.Vector(float(dic['r']) * self.ColScale,
                              float(dic['g']) * self.ColScale,
                              float(dic['b']) * self.ColScale)
        else:
            return c4d.Vector()

if __name__ == "__main__":
    dlg = ExampleDialog()
    dlg.Open(c4d.DLG_TYPE_ASYNC, defaultw=400, defaulth=400)

ferdinand

Hi,

the nature of your problem remains a bit unclear to me. You talk about polygonal data and beveling edges, which I would interpret as the question for bevelling in a network of curves, .e.g. a polygonal topology, but you show the image of a curve and also your code operates in a plane. I assume you want interpret your mesh as a series of cross-sections/curves?

That aside, beveling (either curves or curves in surfaces, i.e. edges) is an application of interpolation and can therefor implemented in various forms, here are some approaches:

Piecing in arc segments. This what you are basically trying to do from the looks of your code. You normally would properly define a series of transforms (i.e. "matrices" in Cinema) to transform a base vector and by that construct the vertices making up the arc segment. This solution is not very suited for a data of intersecting curve networks, i.e. surfaces, it works better in something like a 2D Vector app.
Than there are multiple ways to construct a smooth curve over a series points. The easiest one are Chaikin's Curves which also have spawned a whole group of algorithms all following more or less the same one fourth three fourth idea and some of them can also be applied to meshes.
The next obvious candidates would be quadratic or cubic polynomials/curves. They can the can also be viewed as a combination of linear interpolations. This is called De Casteljau's algorithm. To get from multiple curves segments to splines, you just piece them together (there are multiple ways to do this). But in you case of beveling you probably will only need a single curve. Depending on how deep you venture into this topic this reaches from splines and curves (.e.g. a B-Spline or a Bezier spline) to surfaces (e.g. a NURBS surface).
The last one, and that is the one Cinema probably uses for its edge tool is just Subdivision Surfaces. There are also multiple algorithms of varying complexity, but classical Catmull-Clark SDS have very nice properties (producing only quads for example) and are very easy to implement. The problem here is how to restrict the subdivision part of the algorithm so that you only generate new edges along the edge loop and not perpendicular to it and then come up with the correct modified weights for the smoothing.

Its all a bit vague, but your question is very broad, so I thought this might help.

edit: Forgot this, but should have put this first - Implementing a bevel tool is not trivial. Covering the default case is not that hard, but covering all the corner cases is, especially when you want to maintain secondary mesh attributes like texture coordinates. I would not go for reinventing the wheel here. Is there a reason why you do not want to use Cinema's edge bevel? Does it not work with SendModellingCommand?

Cheers,
zipit

ferdinand

Hoi,

@blastframe said in Moving a Point Along an Arc by Distance from another Point:

In your code comment you mention spherical interpolation between the arc segment. Is that the same as the quadratic bezier interpolation from the example you provided (code below)? I think that's also called slerp?

Yeah, slerp is a synonym for spherical linear interpolation. While linear interpolation, a.k.a. lerp, gives you points on the line segment spanned by its two input vectors, a spherical linear interpolation gives you points on the arc segment spanned between the unit vectors of the two input vectors. Cinema does not have a slerp for vectors for some reason, only one for quaternions. The whole interpolation and interpolation naming situation in Cinema's classic API is a huge mess IMHO. So you would have to write your own slerp. And slerp is not directly related to splines, only in the sense that you will need it when you want to linearly place points on that spline, as you then have to do the arc-length parametrization of that spline for which you will need slerp.

How do I get the points to stop at the limits of the arc? In this case, it would seem to be limiting the angle to 0 and math.pi, but what if the start & end angles are different?

Basically the same way you did it in your code. The computed angle is an angle in radians. So to limit it to let's say [0°, 180°] you would have to clamp it to [0 rad,π rad]. There is also the problem that angles work the other way around in relation to the circle functions sine and cosine and your example. They "start on the right side" of the unit circle and then go counter clockwise. Which is why my code flips things around. Getting back to "your setup" should just a matter of inverting the angle, i.e. -theta instead of theta, and then adding π, i.e. 180°.

If I'm not to use c4d.Vector.GetDistance, how would you recommend I get the geodesic norm? I found modules online like geopy, but I'd rather do it with standard Python.

Its the same thing in green. You get the Euclidean norm, a.k.a the "length" of your vectors, implying the radius of the circle they are sitting on. Then you can compute the angle spanned between them with the dot product. Finally you put this into the relation shown above, solve for the arc length and you are done. And to be clear, Geodesic norm is just a fancy name for saying the distance between two points on a sphere, while the Euclidean norm is the distance in a plane.

Cheers,
zipit

ferdinand

Hi,

preference data is often even for native c4d features implemented as a PreferenceData plugin. You have to access that plugin then. To get there you can drag and drop description elements into the python command line, delete the __getitem__() part (the stuff in brackets), and get the __repr__ of the object. With that you can figure out the plugin ID of the corresponding BasePlugin and then access your values.

For your case as a script example:

import c4d
from c4d import plugins
# Welcome to the world of Python

def main():
    # Search for a plugin ID with a known str __repr__ of a BasePlugin. We got from the console:
    # Drag and drop: Plugins[c4d.PREF_PLUGINS_PATHS]
    # >>> Plugins
    #     <c4d.BaseList2D object called 'Plugins/Plugins' with ID 35 at 0x0000028FE8157A50>
    pid, op = None, plugins.GetFirstPlugin()
    while op:
        if 'Plugins/Plugins' in str(op):
            pid = op.GetID()
            break
        op = op.GetNext()
    print "pid:", pid
    
    # Use that ID
    op = plugins.FindPlugin(pid)
    if op:
        print op[c4d.PREF_PLUGINS_PATHS] # we know the enum from the console

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

You can use then that Plugin ID in cpp to do the last part (Use that ID) there.

Cheers,
zipit

ferdinand

Hello,

here are some answers:

You could use a scripting tag instead of a script to avoid having to deal with the CTRacks at the cost of user interaction.
BaseList2D.GetUserDataContainer() returns a list of DescID and BaseContainer tuples. There is nothing to keyframe there, the BaseContainer only holds the interface settings for that description element. The CTrack and current value of that element are attached to the BaseList2D that does host the user data.
You also do not have to keyframe anything, you can just copy the CTrack and retarget it to the new DescID.

Here is a script which does what you want. I didn't went overboard with your name matching rules, but the rest should be there.

""" I broke things into two parts:
 1. get_matches() deals with building a data structure of matching DescID
  elements.
 2. add_ctracks() then does the building of CTracks.

 You could probably also streamline some stuff here and there, but I tried
 to be verbose so that things are clear. The script also only deals with
 the currently selected object.
"""

import c4d


def get_matches():
    """ Returns a list of tuples of the configuration (source_descid, targets),
    where source_descid is a DescID for which there is a CTrack in op, and
    targets is a list of DescIDs that match source_descid in type and name,
    but there is no CTrack for them in op.
    """

    res, user_data_container = [], op.GetUserDataContainer()

    """ Step through the user data container of op and find elements (sources)
        for which there is a CTrack in op."""
    for source_descid, source_bc in user_data_container:
        if op.FindCTrack(source_descid) is None:
            continue
        target_descid_list = []

        """ Step through the user data container again and find elements
           (targets) for which there is NO CTrack in op and which match the
           current source in type and name."""
        for target_descid, target_bc in user_data_container:
            no_track = op.FindCTrack(target_descid) is None
            if not no_track:
                continue
            match_name = (source_bc[c4d.DESC_NAME][:-2] ==
                          target_bc[c4d.DESC_NAME][:-2])
            match_type = type(op[source_descid]) == type(op[target_descid])
            is_new = sum(target_descid in data for _, data in res) == 0

            if no_track and match_type and match_name and is_new:
                target_descid_list.append(target_descid)
            res.append((source_descid, target_descid_list))
    return res


def add_ctracks(data):
    """ We copy the CTrack for each source DescID the number of target DescID
     which are attached to that source times back into op and set the CTrack 
     DescID each time to the target DescID. 
    """
    for source_did, target_descid_list in data:
        source_ctrack = op.FindCTrack(source_did)
        for target_did in target_descid_list:
            new_ctrack = source_ctrack.GetClone()
            new_ctrack.SetDescriptionID(op, target_did)
            op.InsertTrackSorted(new_ctrack)


def main():
    if op is not None:
        data = get_matches()
        add_ctracks(data)
        op.Message(c4d.MSG_UPDATE)
        c4d.EventAdd()


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

ferdinand

Hi,

you have to unindent op = op.GetNext() one tab or the while loop condition will always be True unless your whole document consists of spline objects.

Cheers
zipit

ferdinand

Hi,

I don't know where you are planning to store your data, but remember that the constant __file__ in Python holds the file path of the currently interpreted script. So os.path.join(os.path.split(__file__)[0], "splinedata") for example would point to a folder called "splinedata" in your plugin directory, no matter where the plugin folder lies (assuming the python file lies on the top level).

You can also get the 'important' c4d paths via c4d.storage.GeGetC4DPath().

Cheers
zipit

ferdinand

Hi,

BitmapButton.SetImage() works just fine. Here is an example on how to set a BitmapButton to a BaseBitmap that has been scaled to fit a target size.

import c4d
from c4d import bitmaps

BUTTONIZE = 128
    
class TextureBakerDlg(c4d.gui.GeDialog):

    def CreateLayout(self):

        # Creates an image preview
        bc = c4d.BaseContainer()
        bc.SetBool(c4d.BITMAPBUTTON_BUTTON, False)
        bc.SetLong(c4d.BITMAPBUTTON_BORDER, c4d.BORDER_THIN_IN)
        self.myBitButton=self.AddCustomGui(1000, c4d.CUSTOMGUI_BITMAPBUTTON, "", 
                                           c4d.BFH_LEFT | c4d.BFV_TOP,
                                           BUTTONIZE, BUTTONIZE,
                                           bc)
        
        # Set up two bitmaps, the source bitmap (it is just the maxon logo in the top 
        # left corner of the forum) and a target sized empty bitmap                  
        src_bmp = bitmaps.BaseBitmap()
        src_bmp.InitWith(
            "https://plugincafe.maxon.net/assets/uploads/system/site-logo.png")
        dst_bmp = bitmaps.BaseBitmap()
        dst_bmp.Init(BUTTONIZE, BUTTONIZE)
        
        # Scale copy our source into the target.
        src_bmp.ScaleIt(dst_bmp, 256, True, True)
        
        # Set your button.
        self.myBitButton.SetImage(dst_bmp)

        return True

def main():
    dlg = TextureBakerDlg()
    dlg.Open(c4d.DLG_TYPE_ASYNC)

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

The fact that you do not see anything / that it 'does not work' for you is probably caused by the fact that you are passing a MultipassBitmap to your button. Check MultipassBitmap.GetLayers on how to access individual layers of BaseBitmaps in your MultipassBitmap which you could then hand to your BitmapButton.

Cheers
zipit

ferdinand

@m_adam said in Distributing Python Plugins that have Dependencies:

Note that once pip is installed you can use pip at runtime on your script How to install and import python modules at runtime.

Hi,

I might be misunderstanding something here, but I still want to point out that espically pip2 is not thread safe and it is explicitly disencouraged to use pip as a module.

Cheers
zipit

ferdinand

Hi,

the trick is to use a dummy STATICTEXT element with the JOINENDSCALE flag. The example is taken from ddoc.res - the file for the project settings dialog. Rember you can (should) always use a text file search tool like Agent Ransack to peek into type, interface or smybol definitions to figure out how things are working.

CONTAINER Ddoc
{
	NAME Ddoc;

	GROUP DOCUMENT_GROUP_PROJECTSETTINGS
	{
		DEFAULT 1;
		COLUMNS 2;

		UNITSCALE DOCUMENT_DOCUNIT { ANIM OFF; }
		STATICTEXT { JOINENDSCALE; }

		BUTTON DOCUMENT_SCALEDOCUMENT {}
		STATICTEXT { }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		LONG DOCUMENT_FPS { ANIM OFF; MIN 1; MAX 2500; }
		BASETIME DOCUMENT_TIME { ANIM OFF; }

		BASETIME DOCUMENT_MINTIME	{ ANIM OFF; }
		BASETIME DOCUMENT_MAXTIME	{ ANIM OFF; }

		BASETIME DOCUMENT_LOOPMINTIME	{ ANIM OFF; }
		BASETIME DOCUMENT_LOOPMAXTIME	{ ANIM OFF; }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }
		
		REAL DOCUMENT_LOD { ANIM OFF; UNIT PERCENT; MIN 0.0; MAX 100.0; }
		BOOL DOCUMENT_RENDERLOD { ANIM OFF; }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		BOOL DOCUMENT_USEANIMATION { ANIM OFF; }
		BOOL DOCUMENT_USEEXPRESSIONS { ANIM OFF; }
		BOOL DOCUMENT_USEGENERATORS { ANIM OFF; }
		BOOL DOCUMENT_USEDEFORMERS { ANIM OFF; }

		BOOL DOCUMENT_USEMOTIONSYSTEM { ANIM OFF; }
		STATICTEXT { }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		LONG DOCUMENT_DEFAULTMATERIAL_TYPE { ALIGN_LEFT; ANIM OFF; CYCLE { DOCUMENT_DEFAULTMATERIAL_TYPE_WHITE; DOCUMENT_DEFAULTMATERIAL_TYPE_BLUE; DOCUMENT_DEFAULTMATERIAL_TYPE_USER; }}
		STATICTEXT { }

		COLOR DOCUMENT_DEFAULTMATERIAL_COLOR { ANIM OFF; FIT_H; }
		STATICTEXT { JOINENDSCALE; }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		LONG DOCUMENT_CLIPPING_PRESET
		{
			ALIGN_LEFT; ANIM OFF; PARENTCOLLAPSE;
			CYCLE
			{
				DOCUMENT_CLIPPING_PRESET_TINY;
				DOCUMENT_CLIPPING_PRESET_SMALL;
				DOCUMENT_CLIPPING_PRESET_MEDIUM;
				DOCUMENT_CLIPPING_PRESET_LARGE;
				DOCUMENT_CLIPPING_PRESET_HUGE;
				DOCUMENT_CLIPPING_PRESET_CUSTOM;
			}
		}
		STATICTEXT { }

		REAL DOCUMENT_CLIPPING_PRESET_NEAR { FIT_H; PARENTCOLLAPSE DOCUMENT_CLIPPING_PRESET; ANIM OFF; UNIT METER; MIN 0; }
		STATICTEXT { JOINENDSCALE; }

		REAL DOCUMENT_CLIPPING_PRESET_FAR { FIT_H; PARENTCOLLAPSE DOCUMENT_CLIPPING_PRESET; ANIM OFF; UNIT METER; MIN 0; }
		STATICTEXT { JOINENDSCALE; }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		BOOL DOCUMENT_LINEARWORKFLOW { ANIM OFF; }
		STATICTEXT { JOINENDSCALE; }
		LONG DOCUMENT_COLORPROFILE { PARENTCOLLAPSE; ANIM OFF; CYCLE { DOCUMENT_COLORPROFILE_SRGB; DOCUMENT_COLORPROFILE_LINEAR; DOCUMENT_COLORPROFILE_DISABLED; }}
		STATICTEXT { }
		
		GROUP
		{
			STRING DOCUMENT_COLORINFO { PARENTCOLLAPSE DOCUMENT_COLORPROFILE; ANIM OFF; CUSTOMGUI MULTISTRING; WORDWRAP; READONLY; }
		}

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }
		
		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		GROUP
		{
			COLUMNS 1;
			BOOL DOCUMENT_CONVERT_BXDF_TO_COLORCHANNEL { ANIM OFF; }
		}
		STATICTEXT { JOINENDSCALE; }

		SEPARATOR { LINE; }
		STATICTEXT { JOINENDSCALE; }

		GROUP
		{
			COLUMNS 2;

			BUTTON	DOCUMENT_PRESET_COMMAND_LOAD		{  }
			BUTTON	DOCUMENT_PRESET_COMMAND_SAVE		{  }
		}
		STATICTEXT { JOINENDSCALE; }
	}

	GROUP DOCUMENT_INFO_GROUP1
	{
		SCALE_V;

		STRING DOCUMENT_INFO_AUTHOR { ANIM OFF; }
		STRING DOCUMENT_INFO_COPYRIGHT { ANIM OFF; CUSTOMGUI MULTISTRING; SCALE_V; WORDWRAP; }
		STRING DOCUMENT_INFO_README { ANIM OFF; CUSTOMGUI MULTISTRING; SCALE_V; WORDWRAP; }
		STATICTEXT DOCUMENT_INFO_FILEFORMAT { ANIM OFF; BORDER; }
		STATICTEXT DOCUMENT_INFO_FILEVERSION { ANIM OFF; BORDER; }

		STATICTEXT DOCUMENT_INFO_PRGCREATOR_STRING { ANIM OFF; BORDER; }
		STRING DOCUMENT_INFO_PRGCREATOR_NAME { HIDDEN; ANIM OFF; }
		LONG DOCUMENT_INFO_PRGCREATOR_ID { HIDDEN; ANIM OFF; }
		STATICTEXT DOCUMENT_INFO_DATECREATED_STRING { ANIM OFF; BORDER; }

		STATICTEXT DOCUMENT_INFO_PRGWRITER_STRING { ANIM OFF; BORDER; }
		STRING DOCUMENT_INFO_PRGWRITER_NAME { HIDDEN; ANIM OFF; }
		LONG DOCUMENT_INFO_PRGWRITER_ID { HIDDEN; ANIM OFF; }
		
		STATICTEXT DOCUMENT_INFO_DATESAVED_STRING { ANIM OFF; BORDER; }
		
		FILENAME DOCUMENT_PATH { HIDDEN; READONLY; ANIM OFF; DIRECTORY; }
		FILENAME DOCUMENT_NAME { HIDDEN; READONLY; ANIM OFF; }
		FILENAME DOCUMENT_FILEPATH { READONLY; ANIM OFF; }

		BITMAPBUTTON DOCUMENT_PREVIEW_IMAGE { SCALE_H; BORDER; }
		LONG DOCUMENT_PREVIEW_COMMAND
		{
			SCALE_H;
			ANIM OFF;
			CUSTOMGUI CYCLEBUTTON; 
			CYCLE 
			{
				DOCUMENT_PREVIEW_COMMAND_AUTO;
				DOCUMENT_PREVIEW_COMMAND_PASTE;
				DOCUMENT_PREVIEW_COMMAND_FROMEDITOR;
				DOCUMENT_PREVIEW_COMMAND_LOAD;
			}
		}
	}

	GROUP DOCUMENT_INFO_GROUP2
	{
		//STRING DOCUMENT_INFO_PREVIEW { ANIM OFF; }
	}
}

Cheers
zipit

ferdinand

Hi,

@bentraje said in Modified Pop Up Menu:

I initially thought the DLG_TYPE_ASYNC_POPUPEDIT or DLG_TYPE_ASYNC_POPUP_RESIZEABLE would do the trick but unfortunately, when you click a command, the dialog does not disappear.

To programmatically close a dialog you have to invoke GeDialog.Close(). So if you want to mimic a popup menu, you should do that after the button event handling.

all_button_ids = [ID_BUTTON_1, ID_BUTTON_2, ...]

def Command(self, id, msg):
    
    if id == ID_BUTTON_1:
        # your button logic ...

    if id in all_button_ids:
        self.Close()

Cheers
zipit

ferdinand

Hi,

@bentraje said in Transparency of GeDialog?:

Is there a way to control the transparency of the GeDialog [...]

To my knowledge there is currently no option to make a GeDialog partially or fully transparent. In the old forum there were quite a few threads on that subject.

If you want some sort of non-rectangular shape for your menu, you will have to spawn multiple dialogs as @maxime did suggest in your initial question.

SetTransparency is a method of BaseDraw meant for user defined polygon drawing operations to render these in a transparent style. You could technically also render your menu directly into a viewport via their associated BaseDraw, but your menu would then be restricted to viewports and also the whole approach would probably be a bit more technically challenging compared to a GeDialog approach.

Cheers
zipit

ferdinand

Hi,

no, I do not have any external render engines here. But you can filter stuff, you just have to compose ar of objects you want to include.

my_filter = [obj for obj in doc.GetMaterials()
             if obj.CheckType(c4d.Mterrain)]
for _, path in doc.GetAllTextures(ar=my_filter):
    print path, "is a texture path in a terrain material."

You can throw everything that is a c4d.C4DAtom into ar. You could try some of the BaseObjects for example that have a texture path.

For external renderer materials: have you confirmed that they are actually included in doc.GetMaterials()?

Also writing a little script, that extracts all bitmap path attributes from a GeListNode (i.e. a shader tree) tree is not too hard either. I think someone asked a similar question in combination with Octane just recently.

Cheers
zipit

ferdinand

Hi,

All NodeData instances have a GeListNode that represents them somewhere in the scene graph. For an ObjectData instance this is a BaseObject for example. It is crucial to understand that your NodeData type is not instantiated into in the scene graph, but is living its life happily as a BaseData somewhere else.
To most methods of NodeData and its derived types this representing node is passed as an argument (with annoyingly inconsistent naming: node in NodeData methods, op in ObjectData methods, and the list goes on). You can also get this node with by invoking NodeData::Get()(really expressive method name, I know).
As described above, your ObjectData plugin is represented by a BaseObjectin the scene graph. BaseObject has multiple methods to access its caches. Most importantly GetCache() and GetDeformCache(). You should always use the second one (the cache of your object after deformers have been applied) unless you are certain that you have to ignore deformers. Note that caches can be empty. In this case you have to fall back to lower caches or do nothing.

Cheers
zipit

ferdinand

Hi,

I cannot reproduce this neither. The interesting question would be what does print random.seed for you and is this reproduceable on your end?

My suspicion would be that someone or something treated random.seed() like a property instead of like a function, which then led to - with all the "Python functions are first class objects" thing - random.seed being an integer. Something like this:

>>> import random
>>> print(random.seed)
<bound method Random.seed of <random.Random object at 0x103b62218>>
>>> random.seed(12345)
>>> random.seed = 12345 # 'accidently' treating it like a property
>>> print(random.seed)
12345
>>> random.seed(12345)
Traceback (most recent call last):
  File "<string>", line 1, in <module>
TypeError: 'int' object is not callable

Cheers
zipit