// Run this just once! Comment out this after the first run.
vtkRenderingOpenGL2_AutoInit_Construct();
//do your stuff
// ATTENTION: Uncomment this and run **before** closing ROOT.
// Failing to do so may result in OpenGL resources not being freed, requiring a system reboot.
// vtkRenderingOpenGL2_AutoInit_Destruct();
```
See if that works. The awkward way to initialize and free resources is to try to mimic the behavior of the static instance.
---
### Author:  [@Wile\_E\_Coyote](https://discourse.vtk.org/u/Wile_E_Coyote)
#### Post date: [July 25, 2021, 2:12pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/9 "2021-07-25T14:12:35Z")
Many thanks for your replies.
I created a [“C++ preprocessor problem” report on the ROOT Forum](https://root-forum.cern.ch/t/c-preprocessor-problem/45999). I assume, in a couple of days, we will get a statement from the ROOT Team.
As I said, there should be no big problems with static singletons:
```cpp
root [0] static struct Foo {
root (cont'ed, cancel with .@) [1]public:
root (cont'ed, cancel with .@) [2] Foo(){}
root (cont'ed, cancel with .@) [3] ~Foo(){}
root (cont'ed, cancel with .@) [4]} foo;
root [5] .class Foo
===========================================================================
struct Foo
SIZE: 1 FILE: ROOT_prompt_0 LINE: 1
List of member variables --------------------------------------------------
List of member functions :---------------------------------------------------
filename line:size busy function type and name
(compiled) (NA):(NA) 0 public: Foo();
(compiled) (NA):(NA) 0 public: ~Foo() noexcept;
root [6]
```
---
### Author:  [@Wile\_E\_Coyote](https://discourse.vtk.org/u/Wile_E_Coyote)
#### Post date: [July 25, 2021, 2:30pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/10 "2021-07-25T14:30:07Z")
When it comes to “`vtkRenderingCore`” and “`vtkRenderingOpenGL2`” …
Running “`ldd libvtkRenderingOpenGL2-9.0.so`” returns (among others) “`libvtkRenderingCore-9.0.so.1`”. That means that the “`vtkRenderingCore`” library will automatically be loaded when one loads “`vtkRenderingOpenGL2`”.
On the other hand, neither “`vtkRenderingCore`” nor “`vtkRenderingOpenGL2`” depend explicitly on “`vtkInteractionStyle`” nor “`vtkRenderingFreeType`”.
So, I will need to collect a list of “automatically” loaded libraries that need “manual” initialization afterward.
Can I assume that every VTK module provides a “`void SomeModule_AutoInit_Construct()`” function?
Of course, it can be completely “dummy”, if a module does not need any special initialization.
If not, how can I learn which modules need it and which do not?
---
### Author:  [@ben.boeckel](https://discourse.vtk.org/u/ben.boeckel)
#### Post date: [July 25, 2021, 4:25pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/11 "2021-07-25T16:25:18Z")
> [@Wile\_E\_Coyote](#):
>
> That means that the “`vtkRenderingCore`” library will automatically be loaded when one loads “`vtkRenderingOpenGL2`”.
Right, but for correctness, if `vtkRenderingCore` is loaded, you need to know to load `vtkRenderingOpenGL2` to make its abstract classes actually work. The Python bindings have the same thing: if one imports just `RenderingCore`, some classes may not work without importing the `RenderingOpenGL2` module to provide implementations.
> [@Wile\_E\_Coyote](#):
>
> Can I assume that every VTK module provides a “`void SomeModule_AutoInit_Construct()`” function?
No, only modules which implement others will have such a function.
---
### Author:  [@Wile\_E\_Coyote](https://discourse.vtk.org/u/Wile_E_Coyote)
#### Post date: [July 25, 2021, 6:24pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/12 "2021-07-25T18:24:45Z")
Many thanks again.
Let me try a “real-life example”.
Looking into the “`CMakeLists.txt`” files for all “`VTK-9.0.x/Examples/Tutorial/Step*/Cxx/Cone*.cxx`” (yes, I know that they currently cannot be built by VTK, but they seem fine for my purposes), I can see the following list of modules:
```nohighlight
CommonCore
FiltersSources
InteractionStyle
InteractionWidgets -> needed by "Step6/Cxx/Cone6.cxx" only
RenderingOpenGL2
```
How can I learn which of these modules needs initialization and which does not?
I assume the order of initialization may be important, too. How can I learn in which order they need to be initialized (e.g., can I assume that I need to do it in the same order in which they appear in the original “`CMakeLists.txt`” files)?
Neither the “`vtkRenderingCore`” nor the “`vtkRenderingFreeType`” are explicitly listed there but, from your previous posts, I assume they need initialization, too (as the “`RenderingOpenGL2`” is used).
How can I learn which “hidden” modules need initialization (and in which order)?
---
### Author:  [@ben.boeckel](https://discourse.vtk.org/u/ben.boeckel)
#### Post date: [July 25, 2021, 7:44pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/13 "2021-07-25T19:44:15Z")
> [@Wile\_E\_Coyote](#):
>
> How can I learn which of these modules needs initialization and which does not?
That information is stored as a property on the CMake target (`_vtk_module_implements` and `_vtk_module_implementable`), so probably not all that accessible to you either where you need it. The order doesn’t matter _too_ much as it is rare that there is more than one implementation at any given time (though there are cases such as `RenderingOpenVR`; in this case, the first one registered “wins” (see [this issue](https://gitlab.kitware.com/vtk/vtk/-/issues/17218))).
> [@Wile\_E\_Coyote](#):
>
> Neither the “`vtkRenderingCore`” nor the “`vtkRenderingFreeType`” are explicitly listed there but, from your previous posts, I assume they need initialization, too (as the “`RenderingOpenGL2`” is used).
> How can I learn which “hidden” modules need initialization (and in which order)?
Those are only needed if interaction or font rendering is needed.
---
### Author:  [@Paulo\_Carvalho](https://discourse.vtk.org/u/Paulo_Carvalho)
#### Post date: [July 25, 2021, 9:33pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/14 "2021-07-25T21:33:51Z")
It seems that you got a solution in ROOT’s forum. Did that work for you? If so, please, post the solution here so others in the future with a problem like youres can benefit from it.
---
### Author:  [@Wile\_E\_Coyote](https://discourse.vtk.org/u/Wile_E_Coyote)
#### Post date: [July 25, 2021, 9:37pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/15 "2021-07-25T21:37:14Z")
Three more questions …
Do modules provide a function which returns, e.g., “true” if they need “initialization”?
I could implement something like this (just a “pseudocode”): “`if (SomeModule_Needs_AutoInit()) VTK_MODULE_INIT(SomeModule);`”
I looked into the “`vtk.module`” files of several modules.
They sometimes contain “IMPLEMENTABLE”, sometimes “IMPLEMENTS”, and sometimes both.
Do I need to “initialize” a module … when the “IMPLEMENTABLE” is present or when the “IMPLEMENTS” is present or in both cases or only if both are present?
Assume I have a list of modules, and I loop over this list, loading the corresponding shared libraries.
Should I “initialize” a module inside this loop as soon as the corresponding shared library is loaded?
Or should I implement an additional loop that will “initialize” modules after all shared libraries were loaded (in the first loop)?
Or maybe it does not matter if it is done in one common or two separate loops?
---
### Author:  [@Wile\_E\_Coyote](https://discourse.vtk.org/u/Wile_E_Coyote)
#### Post date: [July 25, 2021, 9:41pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/16 "2021-07-25T21:41:53Z")
@Paulo_Carvalho Yes, I am able to run all 6 tutorials now. I am still working on it, though (see my previous post). When I’m ready, I will share the “solution”, of course.
---
### Author:  [@ben.boeckel](https://discourse.vtk.org/u/ben.boeckel)
#### Post date: [July 26, 2021, 8:11pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/17 "2021-07-26T20:11:40Z")
> [@Wile\_E\_Coyote](#):
>
> Do modules provide a function which returns, e.g., “true” if they need “initialization”?
No.
> [@Wile\_E\_Coyote](#):
>
> They sometimes contain “IMPLEMENTABLE”, sometimes “IMPLEMENTS”, and sometimes both.
`IMPLEMENTABLE` means “has a factory which can be implemented” and `IMPLEMENTS` lists the modules for which the current module has implementations of. `IMPLEMENTABLE` is there as a sanity check to avoid generating calls to modules which have nothing to register to.
> [@Wile\_E\_Coyote](#):
>
> Or maybe it does not matter if it is done in one common or two separate loops?
Only the order matters (since it is first-come-first-served for the default). The number of loops or whatever is unknown to the registration logic.
---
### Author:  [@Wile\_E\_Coyote](https://discourse.vtk.org/u/Wile_E_Coyote)
#### Post date: [July 27, 2021, 11:36am UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/18 "2021-07-27T11:36:23Z")
@ben.boeckel Many thanks. I will try the following approach then. For every VTK “component”, that I explicitly “load”, I will try to find if an appropriate “`vtk*_AutoInit_Construct`” entry exists in the loaded shared libraries and, if yes, call `VTK_MODULE_INIT` for this “component”.
@Paulo_Carvalho In one of your previous posts, you write that, if one calls “`vtkRenderingOpenGL2_AutoInit_Construct();`”, one is also expected to call “`vtkRenderingOpenGL2_AutoInit_Destruct();`”.
However, the “`VTK_MODULE_INIT(vtkRenderingOpenGL2);`” does NOT do it (there is no destructor).
Moreover, I “scanned” all available shared libraries, and I cannot find any function which name contains “`_AutoInit_Destruct`”.
---
### Author:  [@ben.boeckel](https://discourse.vtk.org/u/ben.boeckel)
#### Post date: [July 27, 2021, 1:01pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/19 "2021-07-27T13:01:33Z")
Yes, there used to be dtor calls, but they were empty functions, so they were just removed. The problem is that the registrations hold pointers into the loaded code and “taking them back” is not generally possible, so unloading a VTK library is not generally possible so instead process teardown is used to undo such registrations.
---
### Author:  [@Paulo\_Carvalho](https://discourse.vtk.org/u/Paulo_Carvalho)
#### Post date: [July 27, 2021, 1:31pm UTC](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236/20 "2021-07-27T13:31:07Z")
> [@Wile\_E\_Coyote](#):
>
> However, the “`VTK_MODULE_INIT(vtkRenderingOpenGL2);`” does NOT do it (there is no destructor).
> Moreover, I “scanned” all available shared libraries, and I cannot find any function which name contains “`_AutoInit_Destruct`”.
It does. Take a look at one of my first posts. I posted the definition of `VTK_MODULE_INIT`. The function with the tilde (~) is the destructor. Leaving out the destructor is up to you, but it is considered bad practice.
[Next page](https://discourse.vtk.org/t/using-vtk-shared-libraries-in-cern-root/6236.md?page=2)