Hello @leon6498 ,

without any further questions and other postings, we will consider this topic as solved and flag it as such by Friday, 17/06/2022.

Thank you for your understanding,
Ferdinand

Hello @pim,

without any further questions and other postings, we will consider this topic as solved and flag it as such by Friday, 17/06/2022.

Thank you for your understanding,
Ferdinand

Hello @jakub,

without any further questions and other postings, we will consider this topic as solved and flag it as such by Friday, 17/06/2022.

Thank you for your understanding,
Ferdinand

We life and learn.
Turns out one must select the material tag with

doc.SetActiveTag(textureTag)

before calling the command

c4d.CallCommand(CMD.GENERATE_UV_COORDS, CMD.GENERATE_UV_COORDS)

to bake the projection down, down into the ground. It now works as intended.

@ferdinand Thanks for your example,I do select a op in the OM.Last time I try it ,it did not work ,but this time it works well,I think last time I use S26 preset python text, and Optional is not import probly, anyway It's work well right now . Great thanks for you

thanks Ferdinand this cleared things up for me

@ferdinand Thank you!

Hello @kbar,

Thank you for reaching out to us. I am sure you are aware that this has been discussed before and nothing has changed here. It is not possible to programmatically instantiate, open, or populate palettes from the public C++ API. While we technically have the possibility to do it internally, our internal code does not really make use of this either. Which is why such a function does not exist although frequently requested.

There are two options you have:

Cinema 4D relies primarily on layouts these days. If you want to provide a specific working environment for users, you can simply provide layout files just as Cinema 4D does. Layout files can be provided for a full layout just as for single palette. Layout files for palettes can be saved from the context menu of a palette.
c5dbdd05-cb75-42f3-a0ab-5ee1a99c5de0-image.png
A layout file can then be loaded back into Cinema 4D with the general-purpose file loading function LoadFile. Find a brief example in Python at the end of this posting. You can provide and structure your product menu with CommandData plugins in such way that they form easy to separate palettes for the user.
9d2f3d55-fca0-43ef-9b6b-ef17caeb3605-image.png

Cheers,
Ferdinand

The result:
palette.gif

The script:

"""Loads a palette file into Cinema 4D. Showcases the ability of LoadFile() to handle almost all file formats Cinema 4D can deal with, including layout files for palettes or the whole window. """ import c4d import os def main() -> None: """Loads a palette into Cinema 4D. """ # Determine and assert the palette file path, the palette file in this # example is meant to be located in the same directory as this script. directory = os.path.dirname(__file__) paletteFile = os.path.join(directory, "myPalette.l4d") if not os.path.exists(paletteFile ): raise OSError(f"The path {paletteFile } does not exist.") # Open the palette with LoadFile(). c4d.documents.LoadFile(paletteFile) if __name__ == '__main__': main()

@ferdinand thanks for explanations and example.

Hi @ferdinand and @Cairyn, thanks for the answers.

There may be a simpler way to achieve an effect similar to what we want (for example, by caching the world matrix at the time t) but I'm still thinking of alternate ways to be able to access the full mesh information at time t. Caching the full mesh is probably not a good option since we would have to update that cache every time the mesh is changed at any time before t (since this might change the mesh at t). A possible option is to restrict the usability a bit and always evaluate the mesh at time 0, I'm checking if this is something we can do.

Feedback loops could be an issue, but it should never happen that (using the example @ferdinand wrote) P relies on T and T also relies on P in this specific plugin. Also, t should always be a time before the current time, although that might not alleviate this particular problem.

In any case, I'm going to go ahead and mark this as solved, I think I got all the information I need to find a solution.

Thank you both very much for helping me out,
Daniel

@ferdinand aaaa i understood, thanks for help megaman)

Hi,

Those IDs should not change but there are not guaranties. There are no symbols to define those IDs.

You can use the following code to displays all the registered Managers.

import c4d from c4d import gui def main(): pluginList = c4d.plugins.FilterPluginList(c4d.PLUGINTYPE_MANAGERINFORMATION, True) for plugin in pluginList: print (plugin, plugin.GetID()) # Execute main() if __name__=='__main__': main()

Cheers,
Manuel

@ferdinand
hey ferdinand , thanks for all of this information !
i also noticed that definitions are missing in the python SDK
(specifically the BlendModes)

hi,

Sorry for the late reply, but this needed investigation and test from my side and communication between me and the dev.

You can create the NodeTemplate that way. I am using the class GradientWorkaround to create the template.
NodesLib::BuildNodeFromDescription must be called with false set to not create the dependency wires.

NodeTemplate t = NodesLib::CreateLazyTemplate(firstNodeId, [firstNodeId]() -> Result<NodeTemplate> { iferr_scope; maxon::nodes::NodeTemplate templ = maxon::nodes::NodesLib::BuildNodeFromDescription(firstNodeId, CoreNodesNodeSystemClass(), false) iferr_return; templ = GradientWorkaround::CreateInit(templ) iferr_return; return templ; }, CoreNodesNodeSystemClass()) iferr_return;

The class itself look like this. We can create a gradient node inside the usernode itself and connect the ports. This is done inside the function InstantiateImpl.

class GradientWorkaround : public maxon::Component<GradientWorkaround, maxon::nodes::NodeTemplateInterface> { MAXON_COMPONENT(NORMAL, maxon::nodes::NodeTemplateBaseClass); public: maxon::ResultOk<void> Init(const maxon::nodes::NodeTemplate& templ) { _wrapped = templ; return maxon::OK; } MAXON_METHOD maxon::Result<Bool> SupportsImpl(const maxon::nodes::NodeSystemClass& cls) const { return cls.IsSubclassOf(CoreNodesNodeSystemClass()); } MAXON_METHOD maxon::Result<maxon::nodes::NodeSystem> InstantiateImpl(const maxon::nodes::InstantiationTrace& parent, const maxon::nodes::TemplateArguments& args) const { iferr_scope; maxon::nodes::NodeSystem sys = _wrapped.Instantiate(parent, args) iferr_return; maxon::nodes::MutableRoot root = sys.BeginInstantiationModification(self) iferr_return; // Asset ID : net.maxon.pattern.node.generator.gradient const AssetRepositoryRef& repository = AssetInterface::GetBuiltinRepository(); nodes::NodeTemplate gradient = nodes::NodesLib::LoadTemplate(repository, Id("net.maxon.pattern.node.generator.gradient")) iferr_return; MutableNode gradientNode = root.AddChild(Id("Gradient"), gradient) iferr_return; const maxon::nodes::MutablePort output = root.GetOutputs().FindPort(maxon::Id("testoutput")) iferr_return; const maxon::nodes::MutablePort gradientPort = root.GetInputs().FindPort(maxon::Id("gradient")) iferr_return; const maxon::nodes::MutablePort gradientResult = gradientNode.GetOutputs().FindPort(maxon::Id("result")) iferr_return; const maxon::nodes::MutablePort gradientGradient = gradientNode.GetInputs().FindPort(maxon::Id("gradient")) iferr_return; gradientResult.Connect(output) iferr_return; gradientPort.Connect(gradientGradient) iferr_return; sys = root.EndModification() iferr_return; return sys; } private: maxon::nodes::NodeTemplate _wrapped; }; MAXON_COMPONENT_CLASS_REGISTER(GradientWorkaround, "net.maxonexample.nodes.class.gradientworkaround");

It is just like having a group of nodes and propagated ports.

Cheers,
Manuel

Thank you very much!

Hey @cairyn,

yeah, you are right. @m_adam already pointed this out too. I screwed up and overwrote my clipboard when I tried this out. I have edited my initial posting, to not confuse future readers.

GetC4DClipboardOwner works fine in regards to the Picture Viewer and Bodypaint, but the argument ownerid of CopyBitmapToClipboard is effectively meaningless in the public API, as it lacks the window handle context to actually cause the ownerid to be stored. The owner id will always be set to 0.

And to underline the answer to your major question: It seems very unlikely that you could crash Cinema 4D with writing a made-up owner id into the clipboard (in the case the function would work properly and actually store the id). It is hard to give here absolute answers, as there is a lot of code in our code base. In the context of the clipboard alone, crashing can be excluded, but there could be other parts of Cinema 4D which make assumptions based on the owner id. Which is why I would recommend not using the predefined ones (which is rather theoretical due to said limitations of CopyBitmapToClipboard).

Cheers,
Ferdinand

@noseman seems that it's needs to be updated
https://github.com/nrosenstein-c4d/c4d-prototype-converter/issues/52

@m_adam
Thanks so much!
You are a very professional guy!!!

hi @cinamatic ,

You should open a new thread for your question as it is not related to this thread.
I found this thread where you will find some useful information about takes and material.

If you have any question, please open your own thread explaining what you are trying to achieve and pointing to those different threads. Futur user will find every information to follow the discussion.

Cheers,
Manuel

@m_magalhaes Thank you!