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

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

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

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

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:

1. 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.

2. 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.

3. 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).

4. 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

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

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

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)

Hi @C4DS and @Motion4D,

thanks you two, that is very kind of you. A happy new year to you too and everyone in the forum.

Cheers,
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

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