I want to finish with this in case someone reads it. Years ago, I asked about the outdated methods when using these techniques. I tried to adjust the depth of the IK spline controls with the actual length of the spline itself. Today, I understand my mistake, as I was trying something that didn’t make logical sense. At the time, I thought it was the best option for what I was looking for.

In short, this was never a problem, and the low response time is normal because the length depends on the depth of the controls. I thought there would be a solution, but choosing this path was not useful.

In conclusion, what eventually satisfied my requirements was directly referencing the angles of the controls, meaning identifying how oriented each control is to another. I took this angle and used it as a factor to multiply by the depth. This model is much more logical and doesn’t have any flaws. At the time, I couldn’t think of a direct solution, but I didn’t want to leave this post like that. Thanks anyway, Ferdinand, for trying to help me.
Cheers
JH

Hi @ferdinand,
Apologies for the lack of context earlier. I didn’t mean that it returns null, but rather that it returns an object inside a null container. When I try to modify the scale of the resulting object, this behavior persists. I’ve noticed a similar pattern when working with Python generators.

import c4d
from c4d import utils
def Cube():
    obj = c4d.PolygonObject(8, 6)

    obj.SetPoint(0, c4d.Vector(-100.0,-100.0,-100.0))
    obj.SetPoint(1, c4d.Vector(-100.0,100.0,-100.0))
    obj.SetPoint(2, c4d.Vector(100.0,-100.0,-100.0))
    obj.SetPoint(3, c4d.Vector(100.0,100.0,-100.0))
    obj.SetPoint(4, c4d.Vector(100.0,-100.0,100.0))
    obj.SetPoint(5, c4d.Vector(100.0,100.0,100.0))
    obj.SetPoint(6, c4d.Vector(-100.0,-100.0,100.0))
    obj.SetPoint(7, c4d.Vector(-100.0,100.0,100.0))

    polygon1 = c4d.CPolygon( 3,2,0,1)#front
    polygon2 = c4d.CPolygon( 5,4,2,3)#left
    polygon3 = c4d.CPolygon( 7,6,4,5)#back
    polygon4 = c4d.CPolygon( 1,0,6,7)#right
    polygon5 = c4d.CPolygon( 2,4,6,0)#down
    polygon6 = c4d.CPolygon( 5,3,1,7)#up

    obj.SetPolygon(0, polygon1)
    obj.SetPolygon(1, polygon2)
    obj.SetPolygon(2, polygon3)
    obj.SetPolygon(3, polygon4)
    obj.SetPolygon(4, polygon5)
    obj.SetPolygon(5, polygon6)

    polygon_count = obj.GetPolygonCount()
    uvw_tag = obj.MakeVariableTag(c4d.Tuvw,polygon_count)
    for i in range(uvw_tag.GetDataCount()):
        uvwdict = uvw_tag.GetSlow(i)
        p1 = c4d.Vector(1,0,0)
        p2 = c4d.Vector(1,1,0)
        p3 = c4d.Vector(0,1,0)
        p4 = c4d.Vector(0,0,0)
        uvw_tag.SetSlow(i, p1, p2, p3, p4)

    obj.SetPhong(True, 1, utils.Rad(40.0))
    obj.Message(c4d.MSG_UPDATE)
    return obj
def main():
    obj = Cube()
    scale = 2
    obj[c4d.ID_BASEOBJECT_REL_SCALE,c4d.VECTOR_X] = scale
    obj[c4d.ID_BASEOBJECT_REL_SCALE,c4d.VECTOR_Y] = scale
    obj[c4d.ID_BASEOBJECT_REL_SCALE,c4d.VECTOR_Z] = scale
    return obj

I’d like to understand why this behavior occurs, and— as I mentioned earlier— if there's a way to define custom behavior for CTSO within a plugin. Once again, sorry for the confusion caused by my previous message.

Just to clarify, modifying the polygon's scale by adjusting its vertices is not an option, since I want the polygon to be generated with those specific attributes already modified.

Thanks for your support,
James H.

I'm creating a basic ObjectData plugin that returns a cube with a modified scale. However, when making the object editable (C key), sometimes the result becomes a Null object with the cube inside, especially after changing the scale.

import c4d
from c4d import plugins, utils

class MyObjectPlugin(plugins.ObjectData):

    def Init(self, op):
        return True

    def GetVirtualObjects(self, op, hierarchyhelp):
        dirty = op.CheckCache(hierarchyhelp) or op.IsDirty(c4d.DIRTY_DATA)
        if not dirty:
            return op.GetCache(hierarchyhelp)

        cube = c4d.BaseObject(c4d.Ocube)
        if cube is None:
            return None

        cube[c4d.ID_BASEOBJECT_REL_SCALE, c4d.VECTOR_X] = 2.0
        cube[c4d.ID_BASEOBJECT_REL_SCALE, c4d.VECTOR_Y] = 1.0
        cube[c4d.ID_BASEOBJECT_REL_SCALE, c4d.VECTOR_Z] = 0.5

        return cube

Am I doing something wrong? My intention is specifically that when making the generator editable, the result is the scaled object, but without the null object that is generated when modifying it, and without modifying the generator scale.

Thanks in advance for any help!

PS: I would also like to know if there is a specific way to return several objects or a specific one when making the generator editable, making it more customizable.

Hey @m_adam,
Thanks for the reply! What you’re saying makes a lot of sense C++ is clearly the better option for this kind of stuff, especially when you need more control and better performance. I haven’t had much chance to dive into C++ yet, but I’m well aware it’s way more powerful than Python when it comes to working with the engine.
It’s a bit of a shame that there’s no way to directly access polygon info from Python, since that’s exactly what I needed. But still, I really appreciate you taking the time to explain it.
Cheers,
James H.

Hi,
I've been trying to understand what type of structure I would need to be able to access what lhit offers, although I know what a PyCobject is, I still don't understand what structure I should use, or what data it affords me, I reviewed the C++ documentation but ended up with more questions than answers, I work in python in a simple sahder, I really don't plan anything elaborate and at this point I'm just testing what information I can get to identify what will be useful to me, I would appreciate it if someone could help me with this problem

import ctypes
import c4d

PyCObject_AsVoidPtr = ctypes.pythonapi.PyCObject_AsVoidPtr 
PyCObject_AsVoidPtr.restype = ctypes.c_void_p
PyCObject_AsVoidPtr.argtypes = [ctypes.py_object]

def Message(sh, msg, data):
    return True
 
def InitRender(sh, irs, customdata): 
    return c4d.INITRENDERRESULT_OK
 
def FreeRender(sh, customdata): 
    pass 
once = True
def Output(sh, cd, customdata):
    global once
    if not cd.vd: 
        return c4d.Vector(0) 

    pyco = cd.vd.lhit
    if not pyco:
        return c4d.Vector(0)

    if once:
        ptr = PyCObject_AsVoidPtr(pyco)
        
        print (ptr)
        
        once = False
        
                
    return c4d.Vector(0) 

I experimented with the PyCObjects of the PolygonObjects and managed to obtain information from the indices. It is not useful to me, but I wanted to know first if it was possible, but I require prior knowledge of the information I hope to obtain. In this case, I feel blind, I would appreciate it if someone would light my way.
thanks in advance
JH

Hi @chuanzhen,
I wanted to say that it is confusing that it fails to create an automatic color when defining the use of icons with custom colors, I suspect a reason why this happens but I am not at all sure, I am still happy that this solution works for you, even so I would like to know if this is something planned or some kind of bug.
Cheers,
James H.

Hello chuanzhen,
I tried this, you're right, it's strange, but curiously if a value is assigned to the color it manages to be created with the defined color without the need for interaction, this is a possible solution, even so I would like to know what could be happening.
Cinema_4D_72OIMo0GEM.mp4
Cheers,
James H.

I want to finish with this in case someone reads it. Years ago, I asked about the outdated methods when using these techniques. I tried to adjust the depth of the IK spline controls with the actual length of the spline itself. Today, I understand my mistake, as I was trying something that didn’t make logical sense. At the time, I thought it was the best option for what I was looking for.

In short, this was never a problem, and the low response time is normal because the length depends on the depth of the controls. I thought there would be a solution, but choosing this path was not useful.

In conclusion, what eventually satisfied my requirements was directly referencing the angles of the controls, meaning identifying how oriented each control is to another. I took this angle and used it as a factor to multiply by the depth. This model is much more logical and doesn’t have any flaws. At the time, I couldn’t think of a direct solution, but I didn’t want to leave this post like that. Thanks anyway, Ferdinand, for trying to help me.
Cheers
JH

Hi,
I reviewed your proposal, it works, but I still feel that ending up using external libraries ends up being a somewhat more uncomfortable problem than not having transparent dialogs, it would be nice if in a future version these details were possible, I have more questions but I prefer to open another thread or investigate better, I appreciate your response.

Cheers,
James H.

Hi,
I wanted to check if this is not already possible, and also ask if you have any ideas for a possible alternative, other than making this UI in the viewport.
regards,
James H.

Hi,
I wanted to ask, is there a way for this to be compatible with deformers or similar, I realized that the tag is not capable of drawing the location of the centers of each polygons altered by deformers, it is curious and I wonder if there is a way to solve it.
Cheers
James H.