1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
|
// pybind 11 related includes
#include <pybind11/pybind11.h>
#include <pybind11/stl.h>
namespace py = pybind11;
// Standard Handle
#include <Standard_Handle.hxx>
// user-defined inclusion per module before includes
// includes to resolve forward declarations
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_Aspects.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_PointSprite.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_TextureSet.hxx>
#include <OpenGl_PointSprite.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Structure.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_ClippingIterator.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_GlFunctions.hxx>
#include <OpenGl_ArbTBO.hxx>
#include <OpenGl_ArbIns.hxx>
#include <OpenGl_ArbDbg.hxx>
#include <OpenGl_ArbFBO.hxx>
#include <OpenGl_ArbFBO.hxx>
#include <OpenGl_ArbSamplerObject.hxx>
#include <OpenGl_ArbTexBindless.hxx>
#include <OpenGl_ExtGS.hxx>
#include <OpenGl_GlCore11Fwd.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_GlCore12.hxx>
#include <OpenGl_GlCore13.hxx>
#include <OpenGl_GlCore14.hxx>
#include <OpenGl_GlCore15.hxx>
#include <OpenGl_GlCore20.hxx>
#include <OpenGl_GlCore21.hxx>
#include <OpenGl_GlCore30.hxx>
#include <OpenGl_GlCore31.hxx>
#include <OpenGl_GlCore32.hxx>
#include <OpenGl_GlCore33.hxx>
#include <OpenGl_GlCore40.hxx>
#include <OpenGl_GlCore41.hxx>
#include <OpenGl_GlCore42.hxx>
#include <OpenGl_GlCore43.hxx>
#include <OpenGl_GlCore44.hxx>
#include <OpenGl_GlCore45.hxx>
#include <OpenGl_GlCore46.hxx>
#include <Graphic3d_Camera.hxx>
#include <Graphic3d_PresentationAttributes.hxx>
#include <OpenGl_Aspects.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_FrameStats.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_FrameStatsData.hxx>
#include <OpenGl_Workspace.hxx>
#include <OpenGl_Context.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_Ax2.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Font_FTFont.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Image_PixMap.hxx>
#include <OpenGl_Texture.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_CStructure.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_ArrayOfTriangles.hxx>
#include <OpenGl_IndexBuffer.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Window.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Structure.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_Workspace.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_IndexBuffer.hxx>
#include <OpenGl_VertexBuffer.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Texture.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Element.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_Group.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_ShadowMap.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <gp_XYZ.hxx>
#include <Graphic3d_Camera.hxx>
#include <Graphic3d_CLight.hxx>
#include <Graphic3d_CView.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_Texture.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Font_TextFormatter.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Texture.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Graphic3d_RenderingParams.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_BackgroundArray.hxx>
#include <OpenGl_DepthPeeling.hxx>
#include <OpenGl_PBREnvironment.hxx>
#include <OpenGl_ShadowMap.hxx>
#include <OpenGl_ShadowMap.hxx>
#include <OpenGl_ShaderObject.hxx>
#include <OpenGl_TextureBuffer.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <Adaptor2d_Curve2d.hxx>
#include <Adaptor3d_Curve.hxx>
#include <Adaptor3d_Surface.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Window.hxx>
// module includes
#include <OpenGl_ArbDbg.hxx>
#include <OpenGl_ArbFBO.hxx>
#include <OpenGl_ArbIns.hxx>
#include <OpenGl_ArbSamplerObject.hxx>
#include <OpenGl_ArbTBO.hxx>
#include <OpenGl_ArbTexBindless.hxx>
#include <OpenGl_Aspects.hxx>
#include <OpenGl_AspectsProgram.hxx>
#include <OpenGl_AspectsSprite.hxx>
#include <OpenGl_AspectsTextureSet.hxx>
#include <OpenGl_BackgroundArray.hxx>
#include <OpenGl_Buffer.hxx>
#include <OpenGl_BufferCompatT.hxx>
#include <OpenGl_CappingAlgo.hxx>
#include <OpenGl_CappingPlaneResource.hxx>
#include <OpenGl_Caps.hxx>
#include <OpenGl_Clipping.hxx>
#include <OpenGl_ClippingIterator.hxx>
#include <OpenGl_Context.hxx>
#include <OpenGl_DepthPeeling.hxx>
#include <OpenGl_Element.hxx>
#include <OpenGl_ExtGS.hxx>
#include <OpenGl_Flipper.hxx>
#include <OpenGl_Font.hxx>
#include <OpenGl_FrameBuffer.hxx>
#include <OpenGl_FrameStats.hxx>
#include <OpenGl_FrameStatsPrs.hxx>
#include <OpenGl_GlCore11.hxx>
#include <OpenGl_GlCore11Fwd.hxx>
#include <OpenGl_GlCore12.hxx>
#include <OpenGl_GlCore13.hxx>
#include <OpenGl_GlCore14.hxx>
#include <OpenGl_GlCore15.hxx>
#include <OpenGl_GlCore20.hxx>
#include <OpenGl_GlCore21.hxx>
#include <OpenGl_GlCore30.hxx>
#include <OpenGl_GlCore31.hxx>
#include <OpenGl_GlCore32.hxx>
#include <OpenGl_GlCore33.hxx>
#include <OpenGl_GlCore40.hxx>
#include <OpenGl_GlCore41.hxx>
#include <OpenGl_GlCore42.hxx>
#include <OpenGl_GlCore43.hxx>
#include <OpenGl_GlCore44.hxx>
#include <OpenGl_GlCore45.hxx>
#include <OpenGl_GlCore46.hxx>
#include <OpenGl_GlFunctions.hxx>
#include <OpenGl_GlNative.hxx>
#include <OpenGl_GlTypes.hxx>
#include <OpenGl_GraduatedTrihedron.hxx>
#include <OpenGl_GraphicDriver.hxx>
#include <OpenGl_GraphicDriverFactory.hxx>
#include <OpenGl_Group.hxx>
#include <OpenGl_HaltonSampler.hxx>
#include <OpenGl_IndexBuffer.hxx>
#include <OpenGl_Layer.hxx>
#include <OpenGl_LayerFilter.hxx>
#include <OpenGl_LayerList.hxx>
#include <OpenGl_LineAttributes.hxx>
#include <OpenGl_Material.hxx>
#include <OpenGl_MaterialState.hxx>
#include <OpenGl_MatrixState.hxx>
#include <OpenGl_NamedResource.hxx>
#include <OpenGl_PBREnvironment.hxx>
#include <OpenGl_PointSprite.hxx>
#include <OpenGl_PrimitiveArray.hxx>
#include <OpenGl_RenderFilter.hxx>
#include <OpenGl_Resource.hxx>
#include <OpenGl_Sampler.hxx>
#include <OpenGl_SceneGeometry.hxx>
#include <OpenGl_SetOfShaderPrograms.hxx>
#include <OpenGl_ShaderManager.hxx>
#include <OpenGl_ShaderObject.hxx>
#include <OpenGl_ShaderProgram.hxx>
#include <OpenGl_ShaderProgramDumpLevel.hxx>
#include <OpenGl_ShaderStates.hxx>
#include <OpenGl_ShadowMap.hxx>
#include <OpenGl_StencilTest.hxx>
#include <OpenGl_Structure.hxx>
#include <OpenGl_StructureShadow.hxx>
#include <OpenGl_Text.hxx>
#include <OpenGl_TextBuilder.hxx>
#include <OpenGl_Texture.hxx>
#include <OpenGl_TextureBuffer.hxx>
#include <OpenGl_TextureBufferArb.hxx>
#include <OpenGl_TextureFormat.hxx>
#include <OpenGl_TextureSet.hxx>
#include <OpenGl_TextureSetPairIterator.hxx>
#include <OpenGl_TileSampler.hxx>
#include <OpenGl_UniformBuffer.hxx>
#include <OpenGl_Vec.hxx>
#include <OpenGl_VertexBuffer.hxx>
#include <OpenGl_VertexBufferCompat.hxx>
#include <OpenGl_VertexBufferEditor.hxx>
#include <OpenGl_View.hxx>
#include <OpenGl_Window.hxx>
#include <OpenGl_Workspace.hxx>
// template related includes
#include "BVH_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "OpenGl_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "NCollection_tmpl.hxx"
#include "OpenGl_tmpl.hxx"
// user-defined pre
#include "OCP_specific.inc"
// user-defined inclusion per module
#include <Message_Messenger.hxx>
#include <Image_SupportedFormats.hxx>
#include <Image_CompressedPixMap.hxx>
#include <Graphic3d_StructureManager.hxx>
struct NSOpenGLContext {};
// Module definiiton
void register_OpenGl_enums(py::module &main_module) {
py::module m = main_module.def_submodule("OpenGl", R"#()#");
// user-defined inclusion per module in the body
py::class_<NSOpenGLContext>(m, "NSOpenGLContext");
// enums
py::enum_<OpenGl_FeatureFlag>(m, "OpenGl_FeatureFlag",R"#(None)#")
.value("OpenGl_FeatureNotAvailable",OpenGl_FeatureFlag::OpenGl_FeatureNotAvailable)
.value("OpenGl_FeatureInExtensions",OpenGl_FeatureFlag::OpenGl_FeatureInExtensions)
.value("OpenGl_FeatureInCore",OpenGl_FeatureFlag::OpenGl_FeatureInCore).export_values();
py::enum_<OpenGl_StateVariable>(m, "OpenGl_StateVariable",R"#(The enumeration of OCCT-specific OpenGL/GLSL variables.)#")
.value("OpenGl_OCC_MODEL_WORLD_MATRIX",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX)
.value("OpenGl_OCC_WORLD_VIEW_MATRIX",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX)
.value("OpenGl_OCC_PROJECTION_MATRIX",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX)
.value("OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE)
.value("OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE)
.value("OpenGl_OCC_PROJECTION_MATRIX_INVERSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_INVERSE)
.value("OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_TRANSPOSE)
.value("OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_TRANSPOSE)
.value("OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_TRANSPOSE)
.value("OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE",OpenGl_StateVariable::OpenGl_OCC_MODEL_WORLD_MATRIX_INVERSE_TRANSPOSE)
.value("OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE",OpenGl_StateVariable::OpenGl_OCC_WORLD_VIEW_MATRIX_INVERSE_TRANSPOSE)
.value("OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE",OpenGl_StateVariable::OpenGl_OCC_PROJECTION_MATRIX_INVERSE_TRANSPOSE)
.value("OpenGl_OCC_CLIP_PLANE_EQUATIONS",OpenGl_StateVariable::OpenGl_OCC_CLIP_PLANE_EQUATIONS)
.value("OpenGl_OCC_CLIP_PLANE_CHAINS",OpenGl_StateVariable::OpenGl_OCC_CLIP_PLANE_CHAINS)
.value("OpenGl_OCC_CLIP_PLANE_COUNT",OpenGl_StateVariable::OpenGl_OCC_CLIP_PLANE_COUNT)
.value("OpenGl_OCC_LIGHT_SOURCE_COUNT",OpenGl_StateVariable::OpenGl_OCC_LIGHT_SOURCE_COUNT)
.value("OpenGl_OCC_LIGHT_SOURCE_TYPES",OpenGl_StateVariable::OpenGl_OCC_LIGHT_SOURCE_TYPES)
.value("OpenGl_OCC_LIGHT_SOURCE_PARAMS",OpenGl_StateVariable::OpenGl_OCC_LIGHT_SOURCE_PARAMS)
.value("OpenGl_OCC_LIGHT_AMBIENT",OpenGl_StateVariable::OpenGl_OCC_LIGHT_AMBIENT)
.value("OpenGl_OCC_LIGHT_SHADOWMAP_SIZE_BIAS",OpenGl_StateVariable::OpenGl_OCC_LIGHT_SHADOWMAP_SIZE_BIAS)
.value("OpenGl_OCC_LIGHT_SHADOWMAP_SAMPLERS",OpenGl_StateVariable::OpenGl_OCC_LIGHT_SHADOWMAP_SAMPLERS)
.value("OpenGl_OCC_LIGHT_SHADOWMAP_MATRICES",OpenGl_StateVariable::OpenGl_OCC_LIGHT_SHADOWMAP_MATRICES)
.value("OpenGl_OCCT_TEXTURE_ENABLE",OpenGl_StateVariable::OpenGl_OCCT_TEXTURE_ENABLE)
.value("OpenGl_OCCT_DISTINGUISH_MODE",OpenGl_StateVariable::OpenGl_OCCT_DISTINGUISH_MODE)
.value("OpenGl_OCCT_PBR_MATERIAL",OpenGl_StateVariable::OpenGl_OCCT_PBR_MATERIAL)
.value("OpenGl_OCCT_COMMON_MATERIAL",OpenGl_StateVariable::OpenGl_OCCT_COMMON_MATERIAL)
.value("OpenGl_OCCT_ALPHA_CUTOFF",OpenGl_StateVariable::OpenGl_OCCT_ALPHA_CUTOFF)
.value("OpenGl_OCCT_COLOR",OpenGl_StateVariable::OpenGl_OCCT_COLOR)
.value("OpenGl_OCCT_OIT_OUTPUT",OpenGl_StateVariable::OpenGl_OCCT_OIT_OUTPUT)
.value("OpenGl_OCCT_OIT_DEPTH_FACTOR",OpenGl_StateVariable::OpenGl_OCCT_OIT_DEPTH_FACTOR)
.value("OpenGl_OCCT_TEXTURE_TRSF2D",OpenGl_StateVariable::OpenGl_OCCT_TEXTURE_TRSF2D)
.value("OpenGl_OCCT_POINT_SIZE",OpenGl_StateVariable::OpenGl_OCCT_POINT_SIZE)
.value("OpenGl_OCCT_VIEWPORT",OpenGl_StateVariable::OpenGl_OCCT_VIEWPORT)
.value("OpenGl_OCCT_LINE_WIDTH",OpenGl_StateVariable::OpenGl_OCCT_LINE_WIDTH)
.value("OpenGl_OCCT_LINE_FEATHER",OpenGl_StateVariable::OpenGl_OCCT_LINE_FEATHER)
.value("OpenGl_OCCT_LINE_STIPPLE_PATTERN",OpenGl_StateVariable::OpenGl_OCCT_LINE_STIPPLE_PATTERN)
.value("OpenGl_OCCT_LINE_STIPPLE_FACTOR",OpenGl_StateVariable::OpenGl_OCCT_LINE_STIPPLE_FACTOR)
.value("OpenGl_OCCT_WIREFRAME_COLOR",OpenGl_StateVariable::OpenGl_OCCT_WIREFRAME_COLOR)
.value("OpenGl_OCCT_QUAD_MODE_STATE",OpenGl_StateVariable::OpenGl_OCCT_QUAD_MODE_STATE)
.value("OpenGl_OCCT_ORTHO_SCALE",OpenGl_StateVariable::OpenGl_OCCT_ORTHO_SCALE)
.value("OpenGl_OCCT_SILHOUETTE_THICKNESS",OpenGl_StateVariable::OpenGl_OCCT_SILHOUETTE_THICKNESS)
.value("OpenGl_OCCT_NB_SPEC_IBL_LEVELS",OpenGl_StateVariable::OpenGl_OCCT_NB_SPEC_IBL_LEVELS)
.value("OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES",OpenGl_StateVariable::OpenGl_OCCT_NUMBER_OF_STATE_VARIABLES).export_values();
py::enum_<OpenGl_UniformStateType>(m, "OpenGl_UniformStateType",R"#(Defines types of uniform state variables.)#")
.value("OpenGl_LIGHT_SOURCES_STATE",OpenGl_UniformStateType::OpenGl_LIGHT_SOURCES_STATE)
.value("OpenGl_CLIP_PLANES_STATE",OpenGl_UniformStateType::OpenGl_CLIP_PLANES_STATE)
.value("OpenGl_MODEL_WORLD_STATE",OpenGl_UniformStateType::OpenGl_MODEL_WORLD_STATE)
.value("OpenGl_WORLD_VIEW_STATE",OpenGl_UniformStateType::OpenGl_WORLD_VIEW_STATE)
.value("OpenGl_PROJECTION_STATE",OpenGl_UniformStateType::OpenGl_PROJECTION_STATE)
.value("OpenGl_MATERIAL_STATE",OpenGl_UniformStateType::OpenGl_MATERIAL_STATE)
.value("OpenGl_SURF_DETAIL_STATE",OpenGl_UniformStateType::OpenGl_SURF_DETAIL_STATE)
.value("OpenGL_OIT_STATE",OpenGl_UniformStateType::OpenGL_OIT_STATE)
.value("OpenGl_UniformStateType_NB",OpenGl_UniformStateType::OpenGl_UniformStateType_NB).export_values();
py::enum_<OpenGl_ShaderProgramDumpLevel>(m, "OpenGl_ShaderProgramDumpLevel",R"#(Definition of shader programs source code dump levels.)#")
.value("OpenGl_ShaderProgramDumpLevel_Off",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Off)
.value("OpenGl_ShaderProgramDumpLevel_Short",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Short)
.value("OpenGl_ShaderProgramDumpLevel_Full",OpenGl_ShaderProgramDumpLevel::OpenGl_ShaderProgramDumpLevel_Full).export_values();
py::enum_<OpenGl_RenderFilter>(m, "OpenGl_RenderFilter",R"#(Filter for rendering elements.)#")
.value("OpenGl_RenderFilter_Empty",OpenGl_RenderFilter::OpenGl_RenderFilter_Empty)
.value("OpenGl_RenderFilter_OpaqueOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_OpaqueOnly)
.value("OpenGl_RenderFilter_TransparentOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_TransparentOnly)
.value("OpenGl_RenderFilter_NonRaytraceableOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_NonRaytraceableOnly)
.value("OpenGl_RenderFilter_FillModeOnly",OpenGl_RenderFilter::OpenGl_RenderFilter_FillModeOnly)
.value("OpenGl_RenderFilter_SkipTrsfPersistence",OpenGl_RenderFilter::OpenGl_RenderFilter_SkipTrsfPersistence).export_values();
py::enum_<OpenGl_MaterialFlag>(m, "OpenGl_MaterialFlag",R"#(Material flag)#")
.value("OpenGl_MaterialFlag_Front",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Front)
.value("OpenGl_MaterialFlag_Back",OpenGl_MaterialFlag::OpenGl_MaterialFlag_Back).export_values();
py::enum_<OpenGl_LayerFilter>(m, "OpenGl_LayerFilter",R"#(Tool object to specify processed OpenGL layers for intermixed rendering of raytracable and non-raytracable layers.)#")
.value("OpenGl_LF_All",OpenGl_LayerFilter::OpenGl_LF_All)
.value("OpenGl_LF_Upper",OpenGl_LayerFilter::OpenGl_LF_Upper)
.value("OpenGl_LF_Bottom",OpenGl_LayerFilter::OpenGl_LF_Bottom)
.value("OpenGl_LF_RayTracable",OpenGl_LayerFilter::OpenGl_LF_RayTracable).export_values();
//Python trampoline classes
class Py_OpenGl_Element : public OpenGl_Element{
public:
using OpenGl_Element::OpenGl_Element;
// public pure virtual
void Render(const opencascade::handle<OpenGl_Workspace> & theWorkspace) const override { PYBIND11_OVERLOAD_PURE(void,OpenGl_Element,Render,theWorkspace) };
void Release(OpenGl_Context * theContext) override { PYBIND11_OVERLOAD_PURE(void,OpenGl_Element,Release,theContext) };
// protected pure virtual
// private pure virtual
};
class Py_OpenGl_Resource : public OpenGl_Resource{
public:
using OpenGl_Resource::OpenGl_Resource;
// public pure virtual
void Release(OpenGl_Context * theGlCtx) override { PYBIND11_OVERLOAD_PURE(void,OpenGl_Resource,Release,theGlCtx) };
Standard_Size EstimatedDataSize() const override { PYBIND11_OVERLOAD_PURE(Standard_Size,OpenGl_Resource,EstimatedDataSize,) };
// protected pure virtual
// private pure virtual
};
class Py_OpenGl_SetterInterface : public OpenGl_SetterInterface{
public:
using OpenGl_SetterInterface::OpenGl_SetterInterface;
// public pure virtual
void Set(const opencascade::handle<OpenGl_Context> & theCtx,const opencascade::handle<Graphic3d_ShaderVariable> & theVariable,OpenGl_ShaderProgram * theProgram) override { PYBIND11_OVERLOAD_PURE(void,OpenGl_SetterInterface,Set,theCtx,theVariable,theProgram) };
// protected pure virtual
// private pure virtual
};
class Py_OpenGl_Buffer : public OpenGl_Buffer{
public:
using OpenGl_Buffer::OpenGl_Buffer;
// public pure virtual
unsigned int GetTarget() const override { PYBIND11_OVERLOAD_PURE(unsigned int,OpenGl_Buffer,GetTarget,) };
// protected pure virtual
// private pure virtual
};
class Py_OpenGl_NamedResource : public OpenGl_NamedResource{
public:
using OpenGl_NamedResource::OpenGl_NamedResource;
// public pure virtual
void Release(OpenGl_Context * theGlCtx) override { PYBIND11_OVERLOAD_PURE(void,OpenGl_Resource,Release,theGlCtx) };
Standard_Size EstimatedDataSize() const override { PYBIND11_OVERLOAD_PURE(Standard_Size,OpenGl_Resource,EstimatedDataSize,) };
// protected pure virtual
// private pure virtual
};
// pre-register typdefs+classes (topologically sorted)
py::class_<OpenGl_ArbDbg , shared_ptr<OpenGl_ArbDbg> >(m,"OpenGl_ArbDbg",R"#(Debug context routines)#");
py::class_<OpenGl_ArbFBO , shared_ptr<OpenGl_ArbFBO> >(m,"OpenGl_ArbFBO",R"#(FBO is available on OpenGL 2.0+ hardware)#");
py::class_<OpenGl_ArbFBOBlit , shared_ptr<OpenGl_ArbFBOBlit> >(m,"OpenGl_ArbFBOBlit",R"#(FBO blit is available in OpenGL 3.0+. Moved out from OpenGl_ArbFBO since it is unavailable in OpenGL ES 2.0.)#");
py::class_<OpenGl_ArbIns , shared_ptr<OpenGl_ArbIns> >(m,"OpenGl_ArbIns",R"#(Instancing is available on OpenGL 3.0+ hardware (in core since OpenGL 3.1 or GL_ARB_draw_instanced extension).)#");
py::class_<OpenGl_ArbSamplerObject , shared_ptr<OpenGl_ArbSamplerObject> >(m,"OpenGl_ArbSamplerObject",R"#(Provide Sampler Object functionality (texture parameters stored independently from texture itself). Available since OpenGL 3.3+ (GL_ARB_sampler_objects extension) and OpenGL ES 3.0+.)#");
py::class_<OpenGl_ArbTBO , shared_ptr<OpenGl_ArbTBO> >(m,"OpenGl_ArbTBO",R"#(TBO is available on OpenGL 3.0+ and OpenGL ES 3.2+ hardware)#");
py::class_<OpenGl_ArbTexBindless , shared_ptr<OpenGl_ArbTexBindless> >(m,"OpenGl_ArbTexBindless",R"#(Provides bindless textures. This extension allows OpenGL applications to access texture objects in shaders without first binding each texture to one of a limited number of texture image units.)#");
py::class_<OpenGl_AspectsProgram , shared_ptr<OpenGl_AspectsProgram> >(m,"OpenGl_AspectsProgram",R"#(OpenGl resources for custom shading program.)#");
py::class_<OpenGl_AspectsSprite , shared_ptr<OpenGl_AspectsSprite> >(m,"OpenGl_AspectsSprite",R"#(OpenGl resources for custom point sprites.)#");
py::class_<OpenGl_AspectsTextureSet , shared_ptr<OpenGl_AspectsTextureSet> >(m,"OpenGl_AspectsTextureSet",R"#(OpenGl resources for custom textures.)#");
py::class_<OpenGl_CappingAlgo , shared_ptr<OpenGl_CappingAlgo> >(m,"OpenGl_CappingAlgo",R"#(Capping surface rendering algorithm.)#");
py::class_<OpenGl_Clipping , shared_ptr<OpenGl_Clipping> >(m,"OpenGl_Clipping",R"#(This class contains logics related to tracking and modification of clipping plane state for particular OpenGl context. It contains information about enabled clipping planes and provides method to change clippings in context. The methods should be executed within OpenGl context associated with instance of this class.)#");
py::class_<OpenGl_ClippingIterator , shared_ptr<OpenGl_ClippingIterator> >(m,"OpenGl_ClippingIterator",R"#(The iterator through clipping planes.)#");
py::class_<OpenGl_ClippingState , shared_ptr<OpenGl_ClippingState> >(m,"OpenGl_ClippingState",R"#(Defines generic state of OCCT clipping state.)#");
py::class_<OpenGl_Element , shared_ptr_nodelete<OpenGl_Element> ,Py_OpenGl_Element >(m,"OpenGl_Element",R"#(Base interface for drawable elements.)#");
py::class_<OpenGl_ElementNode , shared_ptr<OpenGl_ElementNode> >(m,"OpenGl_ElementNode",R"#(None)#");
py::class_<OpenGl_ExtGS , shared_ptr<OpenGl_ExtGS> >(m,"OpenGl_ExtGS",R"#(Geometry shader as extension is available on OpenGL 2.0+)#");
py::class_<OpenGl_GlCore11 , shared_ptr<OpenGl_GlCore11> >(m,"OpenGl_GlCore11",R"#(OpenGL 1.1 core. Notice that all functions within this structure are actually exported by system GL library. The main purpose for these hint - to control visibility of functions per GL version (global functions should not be used directly to achieve this effect!).)#");
py::class_<OpenGl_GlCore11Fwd , shared_ptr<OpenGl_GlCore11Fwd> >(m,"OpenGl_GlCore11Fwd",R"#(OpenGL 1.1 core without deprecated Fixed Pipeline entry points. Notice that all functions within this structure are actually exported by system GL library. The main purpose for these hint - to control visibility of functions per GL version (global functions should not be used directly to achieve this effect!).)#");
py::class_<OpenGl_GlCore12 , shared_ptr<OpenGl_GlCore12> >(m,"OpenGl_GlCore12",R"#(OpenGL 1.2 core based on 1.1 version.)#");
py::class_<OpenGl_GlCore13 , shared_ptr<OpenGl_GlCore13> >(m,"OpenGl_GlCore13",R"#(OpenGL 1.3 without deprecated entry points.)#");
py::class_<OpenGl_GlCore14 , shared_ptr<OpenGl_GlCore14> >(m,"OpenGl_GlCore14",R"#(OpenGL 1.4 core based on 1.3 version.)#");
py::class_<OpenGl_GlCore15 , shared_ptr<OpenGl_GlCore15> >(m,"OpenGl_GlCore15",R"#(OpenGL 1.5 core based on 1.4 version.)#");
py::class_<OpenGl_GlCore20 , shared_ptr<OpenGl_GlCore20> >(m,"OpenGl_GlCore20",R"#(OpenGL 2.0 core based on 1.5 version.)#");
py::class_<OpenGl_GlCore21 , shared_ptr<OpenGl_GlCore21> >(m,"OpenGl_GlCore21",R"#(OpenGL 2.1 core based on 2.0 version.)#");
py::class_<OpenGl_GlCore30 , shared_ptr<OpenGl_GlCore30> >(m,"OpenGl_GlCore30",R"#(OpenGL 3.0 core. This is first version with deprecation model introduced - a lot of functionality regarding to fixed pipeline were marked deprecated. Notice that nothing were actually removed in this version (unless Forward context loaded)!)#");
py::class_<OpenGl_GlCore31 , shared_ptr<OpenGl_GlCore31> >(m,"OpenGl_GlCore31",R"#(OpenGL 3.1 definition.)#");
py::class_<OpenGl_GlCore32 , shared_ptr<OpenGl_GlCore32> >(m,"OpenGl_GlCore32",R"#(OpenGL 3.2 definition.)#");
py::class_<OpenGl_GlCore33 , shared_ptr<OpenGl_GlCore33> >(m,"OpenGl_GlCore33",R"#(OpenGL 3.3 definition.)#");
py::class_<OpenGl_GlCore40 , shared_ptr<OpenGl_GlCore40> >(m,"OpenGl_GlCore40",R"#(OpenGL 4.0 definition.)#");
py::class_<OpenGl_GlCore41 , shared_ptr<OpenGl_GlCore41> >(m,"OpenGl_GlCore41",R"#(OpenGL 4.1 definition.)#");
py::class_<OpenGl_GlCore42 , shared_ptr<OpenGl_GlCore42> >(m,"OpenGl_GlCore42",R"#(OpenGL 4.2 definition.)#");
py::class_<OpenGl_GlCore43 , shared_ptr<OpenGl_GlCore43> >(m,"OpenGl_GlCore43",R"#(OpenGL 4.3 definition.)#");
py::class_<OpenGl_GlCore44 , shared_ptr<OpenGl_GlCore44> >(m,"OpenGl_GlCore44",R"#(OpenGL 4.4 definition.)#");
py::class_<OpenGl_GlCore45 , shared_ptr<OpenGl_GlCore45> >(m,"OpenGl_GlCore45",R"#(OpenGL 4.5 definition.)#");
py::class_<OpenGl_GlCore46 , shared_ptr<OpenGl_GlCore46> >(m,"OpenGl_GlCore46",R"#(OpenGL 4.6 definition.)#");
py::class_<OpenGl_GlFunctions , shared_ptr<OpenGl_GlFunctions> >(m,"OpenGl_GlFunctions",R"#(Mega structure defines the complete list of OpenGL functions.)#");
py::class_<OpenGl_HaltonSampler , shared_ptr<OpenGl_HaltonSampler> >(m,"OpenGl_HaltonSampler",R"#(Compute points of the Halton sequence with digit-permutations for different bases.)#");
py::class_<OpenGl_Material , shared_ptr<OpenGl_Material> >(m,"OpenGl_Material",R"#(OpenGL material definition)#");
py::class_<OpenGl_MaterialCommon , shared_ptr<OpenGl_MaterialCommon> >(m,"OpenGl_MaterialCommon",R"#(OpenGL material definition)#");
py::class_<OpenGl_MaterialPBR , shared_ptr<OpenGl_MaterialPBR> >(m,"OpenGl_MaterialPBR",R"#(OpenGL material definition)#");
py::class_<OpenGl_RaytraceLight , shared_ptr<OpenGl_RaytraceLight> >(m,"OpenGl_RaytraceLight",R"#(Stores properties of OpenGL light source.)#");
py::class_<OpenGl_RaytraceMaterial , shared_ptr<OpenGl_RaytraceMaterial> >(m,"OpenGl_RaytraceMaterial",R"#(Stores properties of surface material.)#");
py::class_<OpenGl_SetterInterface , shared_ptr<OpenGl_SetterInterface> ,Py_OpenGl_SetterInterface >(m,"OpenGl_SetterInterface",R"#(Interface for generic setter of user-defined uniform variables.)#");
py::class_<OpenGl_ShaderUniformLocation , shared_ptr<OpenGl_ShaderUniformLocation> >(m,"OpenGl_ShaderUniformLocation",R"#(Simple class represents GLSL program variable location.)#");
py::class_<OpenGl_StateCounter , shared_ptr<OpenGl_StateCounter> >(m,"OpenGl_StateCounter",R"#(Tool class to implement consistent state counter for objects inside the same driver instance.)#");
py::class_<OpenGl_StateInterface , shared_ptr<OpenGl_StateInterface> >(m,"OpenGl_StateInterface",R"#(Defines interface for OpenGL state.)#");
py::class_<OpenGl_TextBuilder , shared_ptr<OpenGl_TextBuilder> >(m,"OpenGl_TextBuilder",R"#(This class generates primitive array required for rendering textured text using OpenGl_Font instance.)#");
py::class_<OpenGl_TextureFormat , shared_ptr<OpenGl_TextureFormat> >(m,"OpenGl_TextureFormat",R"#(Stores parameters of OpenGL texture format.)#");
py::class_<OpenGl_TextureFormatSelector<GLbyte> , shared_ptr<OpenGl_TextureFormatSelector<GLbyte>> >(m,"OpenGl_TextureFormatSelector_GLbyte",R"#(Specialization for signed byte.)#");
py::class_<OpenGl_TextureFormatSelector<GLfloat> , shared_ptr<OpenGl_TextureFormatSelector<GLfloat>> >(m,"OpenGl_TextureFormatSelector_GLfloat",R"#(Specialization for float.)#");
py::class_<OpenGl_TextureFormatSelector<GLint> , shared_ptr<OpenGl_TextureFormatSelector<GLint>> >(m,"OpenGl_TextureFormatSelector_GLint",R"#(Specialization for signed int.)#");
py::class_<OpenGl_TextureFormatSelector<GLshort> , shared_ptr<OpenGl_TextureFormatSelector<GLshort>> >(m,"OpenGl_TextureFormatSelector_GLshort",R"#(Specialization for signed short.)#");
py::class_<OpenGl_TextureFormatSelector<GLubyte> , shared_ptr<OpenGl_TextureFormatSelector<GLubyte>> >(m,"OpenGl_TextureFormatSelector_GLubyte",R"#(Specialization for unsigned byte.)#");
py::class_<OpenGl_TextureFormatSelector<GLuint> , shared_ptr<OpenGl_TextureFormatSelector<GLuint>> >(m,"OpenGl_TextureFormatSelector_GLuint",R"#(Specialization for unsigned int.)#");
py::class_<OpenGl_TextureFormatSelector<GLushort> , shared_ptr<OpenGl_TextureFormatSelector<GLushort>> >(m,"OpenGl_TextureFormatSelector_GLushort",R"#(Specialization for unsigned short.)#");
py::class_<OpenGl_TextureSetPairIterator , shared_ptr<OpenGl_TextureSetPairIterator> >(m,"OpenGl_TextureSetPairIterator",R"#(Class for iterating pair of texture sets through each defined texture slot. Note that iterator considers texture slots being in ascending order within OpenGl_TextureSet.)#");
py::class_<OpenGl_TileSampler , shared_ptr<OpenGl_TileSampler> >(m,"OpenGl_TileSampler",R"#(Tool object used for sampling screen tiles according to estimated pixel variance (used in path tracing engine). To improve GPU thread coherency, rendering window is split into pixel blocks or tiles. The important feature of this approach is that it is possible to keep the same number of tiles for any screen resolution (e.g. 256 tiles can be used for both 512 x 512 window and 1920 x 1080 window). So, a smaller number of tiles allows to increase interactivity (FPS), but at the cost of higher per-frame variance ('noise'). On the contrary a larger number of tiles decrease interactivity, but leads to lower per-frame variance. Note that the total time needed to produce final final image is the same for both cases.)#");
py::class_<OpenGl_Aspects , shared_ptr<OpenGl_Aspects> , OpenGl_Element >(m,"OpenGl_Aspects",R"#(The element holding Graphic3d_Aspects.)#");
preregister_template_BVH_Triangulation<Standard_ShortReal, 3>(m,"OpenGl_BVHTriangulation3f");
py::class_<OpenGl_Caps ,opencascade::handle<OpenGl_Caps> , Standard_Transient >(m,"OpenGl_Caps",R"#(Class to define graphic driver capabilities. Notice that these options will be ignored if particular functionality does not provided by GL driverClass to define graphic driver capabilities. Notice that these options will be ignored if particular functionality does not provided by GL driver)#");
preregister_template_NCollection_Vector<Standard_Integer>(m,"OpenGl_ColorFormats");
py::class_<OpenGl_Context ,opencascade::handle<OpenGl_Context> , Standard_Transient >(m,"OpenGl_Context",R"#(This class generalize access to the GL context and available extensions.This class generalize access to the GL context and available extensions.)#");
py::class_<OpenGl_Flipper , shared_ptr<OpenGl_Flipper> , OpenGl_Element >(m,"OpenGl_Flipper",R"#(Being rendered, the elements modifies current model-view matrix such that the axes of the specified reference system (in model space) become oriented in the following way: - X - heads to the right side of view. - Y - heads to the up side of view. - N(Z) - heads towards the screen. Originally, this element serves for need of flipping the 3D text of dimension presentations.)#");
py::class_<OpenGl_FrameStats ,opencascade::handle<OpenGl_FrameStats> , Graphic3d_FrameStats >(m,"OpenGl_FrameStats",R"#(Class storing the frame statistics.Class storing the frame statistics.)#");
py::class_<OpenGl_FrameStatsPrs , shared_ptr<OpenGl_FrameStatsPrs> , OpenGl_Element >(m,"OpenGl_FrameStatsPrs",R"#(Element rendering frame statistics.)#");
py::class_<OpenGl_GraphicDriver ,opencascade::handle<OpenGl_GraphicDriver> , Graphic3d_GraphicDriver >(m,"OpenGl_GraphicDriver",R"#(This class defines an OpenGl graphic driverThis class defines an OpenGl graphic driver)#");
py::class_<OpenGl_GraphicDriverFactory ,opencascade::handle<OpenGl_GraphicDriverFactory> , Graphic3d_GraphicDriverFactory >(m,"OpenGl_GraphicDriverFactory",R"#(This class for creation of OpenGl_GraphicDriver.)#");
py::class_<OpenGl_Group ,opencascade::handle<OpenGl_Group> , Graphic3d_Group >(m,"OpenGl_Group",R"#(Implementation of low-level graphic group.Implementation of low-level graphic group.)#");
preregister_template_OpenGl_BufferCompatT<OpenGl_IndexBuffer>(m,"OpenGl_IndexBufferCompat");
py::class_<OpenGl_LightSourceState , shared_ptr<OpenGl_LightSourceState> , OpenGl_StateInterface >(m,"OpenGl_LightSourceState",R"#(Defines state of OCCT light sources.)#");
preregister_template_NCollection_List<const OpenGl_Structure *>(m,"OpenGl_ListOfStructure");
py::class_<OpenGl_MaterialState , shared_ptr<OpenGl_MaterialState> , OpenGl_StateInterface >(m,"OpenGl_MaterialState",R"#(Defines generic state of material properties.)#");
py::class_<OpenGl_ModelWorldState , shared_ptr<OpenGl_ModelWorldState> , OpenGl_StateInterface >(m,"OpenGl_ModelWorldState",R"#(Defines state of OCCT model-world transformation.)#");
py::class_<OpenGl_OitState , shared_ptr<OpenGl_OitState> , OpenGl_StateInterface >(m,"OpenGl_OitState",R"#(Defines generic state of order-independent transparency rendering properties.)#");
py::class_<OpenGl_PrimitiveArray , shared_ptr<OpenGl_PrimitiveArray> , OpenGl_Element >(m,"OpenGl_PrimitiveArray",R"#(Class for rendering of arbitrary primitive array.)#");
py::class_<OpenGl_ProjectionState , shared_ptr<OpenGl_ProjectionState> , OpenGl_StateInterface >(m,"OpenGl_ProjectionState",R"#(Defines state of OCCT projection transformation.)#");
py::class_<OpenGl_Resource ,opencascade::handle<OpenGl_Resource> ,Py_OpenGl_Resource , Standard_Transient >(m,"OpenGl_Resource",R"#(Interface for OpenGl resource with following meaning: - object can be constructed at any time; - should be explicitly Initialized within active OpenGL context; - should be explicitly Released within active OpenGL context (virtual Release() method); - can be destroyed at any time. Destruction of object with unreleased GPU resources will cause leaks which will be ignored in release mode and will immediately stop program execution in debug mode using assert.Interface for OpenGl resource with following meaning: - object can be constructed at any time; - should be explicitly Initialized within active OpenGL context; - should be explicitly Released within active OpenGL context (virtual Release() method); - can be destroyed at any time. Destruction of object with unreleased GPU resources will cause leaks which will be ignored in release mode and will immediately stop program execution in debug mode using assert.)#");
py::class_<OpenGl_SetOfPrograms ,opencascade::handle<OpenGl_SetOfPrograms> , Standard_Transient >(m,"OpenGl_SetOfPrograms",R"#(Alias to programs array of predefined length)#");
py::class_<OpenGl_SetOfShaderPrograms ,opencascade::handle<OpenGl_SetOfShaderPrograms> , Standard_Transient >(m,"OpenGl_SetOfShaderPrograms",R"#(Alias to 2D programs array of predefined length)#");
preregister_template_NCollection_Sequence<opencascade::handle<OpenGl_ShaderObject>>(m,"OpenGl_ShaderList");
py::class_<OpenGl_ShaderManager ,opencascade::handle<OpenGl_ShaderManager> , Graphic3d_ShaderManager >(m,"OpenGl_ShaderManager",R"#(This class is responsible for managing shader programs.)#");
preregister_template_NCollection_Sequence<opencascade::handle<OpenGl_ShaderProgram>>(m,"OpenGl_ShaderProgramList");
py::class_<OpenGl_ShadowMapArray ,opencascade::handle<OpenGl_ShadowMapArray> , Standard_Transient >(m,"OpenGl_ShadowMapArray",R"#(Array of shadow maps.)#");
py::class_<OpenGl_StencilTest , shared_ptr_nodelete<OpenGl_StencilTest> , OpenGl_Element >(m,"OpenGl_StencilTest",R"#(None)#");
py::class_<OpenGl_Structure ,opencascade::handle<OpenGl_Structure> , Graphic3d_CStructure >(m,"OpenGl_Structure",R"#(Implementation of low-level graphic structure.Implementation of low-level graphic structure.)#");
py::class_<OpenGl_Text , shared_ptr<OpenGl_Text> , OpenGl_Element >(m,"OpenGl_Text",R"#(Text rendering)#");
py::class_<OpenGl_TextureSet ,opencascade::handle<OpenGl_TextureSet> , Standard_Transient >(m,"OpenGl_TextureSet",R"#(Class holding array of textures to be mapped as a set. Textures should be defined in ascending order of texture units within the set.)#");
preregister_template_OpenGl_BufferCompatT<OpenGl_VertexBuffer>(m,"OpenGl_VertexBufferCompat");
py::class_<OpenGl_View ,opencascade::handle<OpenGl_View> , Graphic3d_CView >(m,"OpenGl_View",R"#(Implementation of OpenGl view.Implementation of OpenGl view.)#");
py::class_<OpenGl_Window ,opencascade::handle<OpenGl_Window> , Standard_Transient >(m,"OpenGl_Window",R"#(This class represents low-level wrapper over window with GL context. The window itself should be provided to constructor.This class represents low-level wrapper over window with GL context. The window itself should be provided to constructor.)#");
py::class_<OpenGl_Workspace ,opencascade::handle<OpenGl_Workspace> , Standard_Transient >(m,"OpenGl_Workspace",R"#(Rendering workspace. Provides methods to render primitives and maintain GL state.Rendering workspace. Provides methods to render primitives and maintain GL state.Rendering workspace. Provides methods to render primitives and maintain GL state.)#");
py::class_<OpenGl_WorldViewState , shared_ptr<OpenGl_WorldViewState> , OpenGl_StateInterface >(m,"OpenGl_WorldViewState",R"#(Defines state of OCCT world-view transformation.)#");
py::class_<OpenGl_BackgroundArray , shared_ptr<OpenGl_BackgroundArray> , OpenGl_PrimitiveArray >(m,"OpenGl_BackgroundArray",R"#(Tool class for generating reusable data for gradient or texture background rendering.)#");
py::class_<OpenGl_Buffer ,opencascade::handle<OpenGl_Buffer> ,Py_OpenGl_Buffer , OpenGl_Resource >(m,"OpenGl_Buffer",R"#(Buffer Object - is a general storage object for arbitrary data (see sub-classes).Buffer Object - is a general storage object for arbitrary data (see sub-classes).)#");
py::class_<OpenGl_CappingPlaneResource ,opencascade::handle<OpenGl_CappingPlaneResource> , OpenGl_Resource >(m,"OpenGl_CappingPlaneResource",R"#(Container of graphical resources for rendering capping plane associated to graphical clipping plane. This resource holds data necessary for OpenGl_CappingAlgo. This object is implemented as OpenGl resource for the following reasons: - one instance should be shared between contexts. - instance associated to Graphic3d_ClipPlane data by id. - should created and released within context (owns OpenGl elements and resources).Container of graphical resources for rendering capping plane associated to graphical clipping plane. This resource holds data necessary for OpenGl_CappingAlgo. This object is implemented as OpenGl resource for the following reasons: - one instance should be shared between contexts. - instance associated to Graphic3d_ClipPlane data by id. - should created and released within context (owns OpenGl elements and resources).Container of graphical resources for rendering capping plane associated to graphical clipping plane. This resource holds data necessary for OpenGl_CappingAlgo. This object is implemented as OpenGl resource for the following reasons: - one instance should be shared between contexts. - instance associated to Graphic3d_ClipPlane data by id. - should created and released within context (owns OpenGl elements and resources).)#");
py::class_<OpenGl_Font ,opencascade::handle<OpenGl_Font> , OpenGl_Resource >(m,"OpenGl_Font",R"#(Texture font.Texture font.)#");
py::class_<OpenGl_LineAttributes ,opencascade::handle<OpenGl_LineAttributes> , OpenGl_Resource >(m,"OpenGl_LineAttributes",R"#(Utility class to manage OpenGL resources of polygon hatching styles.Utility class to manage OpenGL resources of polygon hatching styles.)#");
py::class_<OpenGl_NamedResource ,opencascade::handle<OpenGl_NamedResource> ,Py_OpenGl_NamedResource , OpenGl_Resource >(m,"OpenGl_NamedResource",R"#(Named resource object.)#");
py::class_<OpenGl_Sampler ,opencascade::handle<OpenGl_Sampler> , OpenGl_Resource >(m,"OpenGl_Sampler",R"#(Class implements OpenGL sampler object resource that stores the sampling parameters for a texture access.Class implements OpenGL sampler object resource that stores the sampling parameters for a texture access.)#");
py::class_<OpenGl_ShaderObject ,opencascade::handle<OpenGl_ShaderObject> , OpenGl_Resource >(m,"OpenGl_ShaderObject",R"#(Wrapper for OpenGL shader object.Wrapper for OpenGL shader object.)#");
py::class_<OpenGl_StructureShadow ,opencascade::handle<OpenGl_StructureShadow> , OpenGl_Structure >(m,"OpenGl_StructureShadow",R"#(Dummy structure which just redirects to groups of another structure.Dummy structure which just redirects to groups of another structure.)#");
py::class_<OpenGl_TriangleSet , shared_ptr<OpenGl_TriangleSet> , OpenGl_BVHTriangulation3f >(m,"OpenGl_TriangleSet",R"#(Triangulation of single OpenGL primitive array.)#");
py::class_<OpenGl_DepthPeeling ,opencascade::handle<OpenGl_DepthPeeling> , OpenGl_NamedResource >(m,"OpenGl_DepthPeeling",R"#(Class provides FBOs for dual depth peeling.)#");
py::class_<OpenGl_FrameBuffer ,opencascade::handle<OpenGl_FrameBuffer> , OpenGl_NamedResource >(m,"OpenGl_FrameBuffer",R"#(Class implements FrameBuffer Object (FBO) resource intended for off-screen rendering.Class implements FrameBuffer Object (FBO) resource intended for off-screen rendering.)#");
py::class_<OpenGl_IndexBuffer ,opencascade::handle<OpenGl_IndexBuffer> , OpenGl_Buffer >(m,"OpenGl_IndexBuffer",R"#(Index buffer is just a VBO with special target (GL_ELEMENT_ARRAY_BUFFER).Index buffer is just a VBO with special target (GL_ELEMENT_ARRAY_BUFFER).)#");
py::class_<OpenGl_PBREnvironment ,opencascade::handle<OpenGl_PBREnvironment> , OpenGl_NamedResource >(m,"OpenGl_PBREnvironment",R"#(This class contains specular and diffuse maps required for Image Base Lighting (IBL) in PBR shading model with it's generation methods.)#");
py::class_<OpenGl_ShaderProgram ,opencascade::handle<OpenGl_ShaderProgram> , OpenGl_NamedResource >(m,"OpenGl_ShaderProgram",R"#(Wrapper for OpenGL program object.Wrapper for OpenGL program object.Wrapper for OpenGL program object.)#");
py::class_<OpenGl_ShadowMap ,opencascade::handle<OpenGl_ShadowMap> , OpenGl_NamedResource >(m,"OpenGl_ShadowMap",R"#(This class contains shadow mapping resources.)#");
py::class_<OpenGl_Texture ,opencascade::handle<OpenGl_Texture> , OpenGl_NamedResource >(m,"OpenGl_Texture",R"#(Texture resource.Texture resource.)#");
py::class_<OpenGl_TextureBuffer ,opencascade::handle<OpenGl_TextureBuffer> , OpenGl_Buffer >(m,"OpenGl_TextureBuffer",R"#(Texture Buffer Object. This is a special 1D texture that VBO-style initialized. The main differences from general 1D texture: - no interpolation between field; - greater sizes; - special sampler object in GLSL shader to access data by index.Texture Buffer Object. This is a special 1D texture that VBO-style initialized. The main differences from general 1D texture: - no interpolation between field; - greater sizes; - special sampler object in GLSL shader to access data by index.)#");
py::class_<OpenGl_UniformBuffer ,opencascade::handle<OpenGl_UniformBuffer> , OpenGl_Buffer >(m,"OpenGl_UniformBuffer",R"#(Uniform buffer object.)#");
py::class_<OpenGl_VertexBuffer ,opencascade::handle<OpenGl_VertexBuffer> , OpenGl_Buffer >(m,"OpenGl_VertexBuffer",R"#(Vertex Buffer Object - is a general storage object for vertex attributes (position, normal, color). Notice that you should use OpenGl_IndexBuffer specialization for array of indices.Vertex Buffer Object - is a general storage object for vertex attributes (position, normal, color). Notice that you should use OpenGl_IndexBuffer specialization for array of indices.)#");
py::class_<OpenGl_PointSprite ,opencascade::handle<OpenGl_PointSprite> , OpenGl_Texture >(m,"OpenGl_PointSprite",R"#(Point sprite resource. On modern hardware it will be texture with extra parameters. On ancient hardware sprites will be drawn using bitmaps.Point sprite resource. On modern hardware it will be texture with extra parameters. On ancient hardware sprites will be drawn using bitmaps.Point sprite resource. On modern hardware it will be texture with extra parameters. On ancient hardware sprites will be drawn using bitmaps.)#");
};
// user-defined post-inclusion per module
// user-defined post
|
