Interesting - not even pressing Execute in the Expression Editor creates an output if the viewport is not visible. Duh, I would have expected that. Maybe it's an actual bug.

You may want to make a viewport visible.

Apparently, your viewport is somewhere in the background. Under those circumstances, the evaluation of the object tree seems to skip a beat... C4D seems to be thinking "hey, if you don't wanna see my results, I won't bother doing anything" ;-)

I verified this on my system - no viewport, no output!

(Don't ask me why Maxon is doing that, I don't have access to the inner code...)

The code actually works fine for me being in a Python Tag on a Cube. When the scene is refreshed, the tag is executed, and the console shows the version line.

What's happening (or not happening) on your side? Remember that you need to trigger the execution of the tag by doing something in the scene like selecting or forwarding the timeline; the execution context is different from the script manager (where you explicitly trigger the execution by clicking "Execute"). With a tag, the execution is bound to the evaluation of the scene tree.

Speaking of regular expressions, I find it often useful to utilize the "raw" notation for strings to avoid double-escape character sequences, which can add another layer of confusion:

RE_STRIP_NUMERIC_AFFIX = re.compile(r"(^\S+)(\.)(\d+$)")

Thanks, it's good to know that there are internal functionalities actually using these flags!

@PluginStudent said in NBIT xHIDE visibility flags - THIDE deprecated?:

Just to throw a few things in: you can check the visibility of an object in the editor by combining CheckDisplayFilter() and CheckEditorVisibility() (BaseView / BaseDraw Manual).

A tag is not visible in the Object Manager if the tag flag TAG_VISIBLE is not set. The tag visibility is not something that is supposed to be switched at runtime.

Thanks, but that's what I mean by orthogonal, there are many ways how things can be made invisible... TAG_VISIBLE is a tag property that does not make use of OHIDE (nor can you override this property by the OHIDE flag). OHIDE can affect a tag and make it invisible similar as if it has the TAG_VISIBLE property set, but it is a different method and can be changed at runtime.

CheckEditorVisibility would probably check several orthogonal visibility properties (according to the documentation) - as I just looked up, it doesn't exist in the Python API though, so you can only use it with C++.

@zipit By "orthogonal", I mean that the multiple visibility concepts - like the traffic lights, the polygon hiding, the OHIDE bit, the name filter, the object filter - can all be used at the same time without influencing each other.

The HIDE bits are not set by any other functionality (as far as I can see). Take a polygon object for example, if you list its tags you will find two tags that do not appear in the OM: point and polygon tag. However, neither of these tags has the OHIDE bit set, so the mechanism that hides them is different.

Same for viewport filters, e.g. - you can hide a Generator object, and it disappears from the viewport. But the EHIDE bit is not involved; it is not being set by the filter. So, these mechanisms are orthogonal; the total visibility is something of a formula "if not filtered and not EHIDE and not switched off by traffic light and active", with each condition being separate and independent.

Hello;

I was just checking out the NBIT visibility flags, and they raise a few questions...

1. NBIT_THIDE doesn't seem to do anything. I can see that there are timeline-window-specific versions NBIT_TL1_HIDE (etc) which do work, but THIDE is not marked as deprecated and says Hide object in Timeline in both the C++ and Python documantation. A relic? Or it it now used for different purposes?

2. From experiments, I assume that NBIT_TL1_HIDE needs to be set on the tracks too (as these still remain visible when I hide the parent object in the timeline).

3. NBIT_OHIDE and NBIT_EHIDE work as expected. (So other than the timeline hide flags, there is no object-manager-window-specific hiding flag OM1_HIDE.)
   These flags seem to be accessible only in a programmatical way though. I can't find any C4D functionality that would use these flags (object type filters, viewport filters, name filters, ...). All "visibility concepts" seem to be orthogonal. Or am I overlooking something?

4. On the other paw, TL1_HIDE does have a C4D function that uses it (Hide selected elements in the timeline menu sets this flag). There are apparently no equivalent functions in the object manager or the material manager...?

Just to point out, I already answered & posted a full sample scene in this thread:
https://www.c4dcafe.com/ipb/forums/topic/109504-python-vertex-map/
plus a detailed explanation on how vertex map calculation works in a free post on my Patreon:
https://www.patreon.com/posts/script-club-1-07-34384586

(Just so we don't get work duplicated.)

If you have two materials, and both use a certain shader, then these shader are (as you have noticed) still different objects at different memory addresses. Since C4D classes are mutable (other than, say, the Python integer class) Python cannot reuse the object. After all, the user may at any time change a parameter in the shader used by material 1, but not the equivalent shader used by material 2, resulting in 2 different shader instances.

With all hierarchical structure based on dynamic objects, you need to perform the comparison recursively (deeply), or you will run into the issue that data identity is not necessarily object identity. If you're lucky, your classes contain a deep comparison function already; otherwise, you need to go into the objects-to-compare and continue on that level, all the way down.