diff options
Diffstat (limited to 'ddl/out/IR.hpp')
-rw-r--r-- | ddl/out/IR.hpp | 1070 |
1 files changed, 1070 insertions, 0 deletions
diff --git a/ddl/out/IR.hpp b/ddl/out/IR.hpp new file mode 100644 index 0000000..3c6055f --- /dev/null +++ b/ddl/out/IR.hpp | |||
@@ -0,0 +1,1070 @@ | |||
1 | // generated file, do not modify! | ||
2 | // 2015-12-21T12:00:19.420877000000Z | ||
3 | |||
4 | #ifndef HEADER_IR_H | ||
5 | #define HEADER_IR_H | ||
6 | |||
7 | #include "RT.hpp" | ||
8 | |||
9 | |||
10 | typedef Int StreamName; | ||
11 | |||
12 | typedef Int ProgramName; | ||
13 | |||
14 | typedef Int TextureName; | ||
15 | |||
16 | typedef Int SamplerName; | ||
17 | |||
18 | typedef String UniformName; | ||
19 | |||
20 | typedef Int SlotName; | ||
21 | |||
22 | typedef Int FrameBufferComponent; | ||
23 | |||
24 | typedef Int TextureUnit; | ||
25 | |||
26 | typedef Int RenderTargetName; | ||
27 | |||
28 | typedef std::map<::UniformName, ::TextureUnit> TextureUnitMapping; | ||
29 | |||
30 | class ArrayValue { | ||
31 | public: | ||
32 | enum class tag { | ||
33 | VBoolArray, | ||
34 | VIntArray, | ||
35 | VWordArray, | ||
36 | VFloatArray | ||
37 | } tag; | ||
38 | }; | ||
39 | namespace data { | ||
40 | class VBoolArray : public ::ArrayValue { | ||
41 | public: | ||
42 | std::vector<Bool> _0; | ||
43 | VBoolArray() { tag = tag::VBoolArray; } | ||
44 | }; | ||
45 | class VIntArray : public ::ArrayValue { | ||
46 | public: | ||
47 | std::vector<Int32> _0; | ||
48 | VIntArray() { tag = tag::VIntArray; } | ||
49 | }; | ||
50 | class VWordArray : public ::ArrayValue { | ||
51 | public: | ||
52 | std::vector<Word32> _0; | ||
53 | VWordArray() { tag = tag::VWordArray; } | ||
54 | }; | ||
55 | class VFloatArray : public ::ArrayValue { | ||
56 | public: | ||
57 | std::vector<Float> _0; | ||
58 | VFloatArray() { tag = tag::VFloatArray; } | ||
59 | }; | ||
60 | } | ||
61 | class Value { | ||
62 | public: | ||
63 | enum class tag { | ||
64 | VBool, | ||
65 | VV2B, | ||
66 | VV3B, | ||
67 | VV4B, | ||
68 | VWord, | ||
69 | VV2U, | ||
70 | VV3U, | ||
71 | VV4U, | ||
72 | VInt, | ||
73 | VV2I, | ||
74 | VV3I, | ||
75 | VV4I, | ||
76 | VFloat, | ||
77 | VV2F, | ||
78 | VV3F, | ||
79 | VV4F, | ||
80 | VM22F, | ||
81 | VM23F, | ||
82 | VM24F, | ||
83 | VM32F, | ||
84 | VM33F, | ||
85 | VM34F, | ||
86 | VM42F, | ||
87 | VM43F, | ||
88 | VM44F | ||
89 | } tag; | ||
90 | }; | ||
91 | namespace data { | ||
92 | class VBool : public ::Value { | ||
93 | public: | ||
94 | Bool _0; | ||
95 | VBool() { tag = tag::VBool; } | ||
96 | }; | ||
97 | class VV2B : public ::Value { | ||
98 | public: | ||
99 | V2B _0; | ||
100 | VV2B() { tag = tag::VV2B; } | ||
101 | }; | ||
102 | class VV3B : public ::Value { | ||
103 | public: | ||
104 | V3B _0; | ||
105 | VV3B() { tag = tag::VV3B; } | ||
106 | }; | ||
107 | class VV4B : public ::Value { | ||
108 | public: | ||
109 | V4B _0; | ||
110 | VV4B() { tag = tag::VV4B; } | ||
111 | }; | ||
112 | class VWord : public ::Value { | ||
113 | public: | ||
114 | Word32 _0; | ||
115 | VWord() { tag = tag::VWord; } | ||
116 | }; | ||
117 | class VV2U : public ::Value { | ||
118 | public: | ||
119 | V2U _0; | ||
120 | VV2U() { tag = tag::VV2U; } | ||
121 | }; | ||
122 | class VV3U : public ::Value { | ||
123 | public: | ||
124 | V3U _0; | ||
125 | VV3U() { tag = tag::VV3U; } | ||
126 | }; | ||
127 | class VV4U : public ::Value { | ||
128 | public: | ||
129 | V4U _0; | ||
130 | VV4U() { tag = tag::VV4U; } | ||
131 | }; | ||
132 | class VInt : public ::Value { | ||
133 | public: | ||
134 | Int32 _0; | ||
135 | VInt() { tag = tag::VInt; } | ||
136 | }; | ||
137 | class VV2I : public ::Value { | ||
138 | public: | ||
139 | V2I _0; | ||
140 | VV2I() { tag = tag::VV2I; } | ||
141 | }; | ||
142 | class VV3I : public ::Value { | ||
143 | public: | ||
144 | V3I _0; | ||
145 | VV3I() { tag = tag::VV3I; } | ||
146 | }; | ||
147 | class VV4I : public ::Value { | ||
148 | public: | ||
149 | V4I _0; | ||
150 | VV4I() { tag = tag::VV4I; } | ||
151 | }; | ||
152 | class VFloat : public ::Value { | ||
153 | public: | ||
154 | Float _0; | ||
155 | VFloat() { tag = tag::VFloat; } | ||
156 | }; | ||
157 | class VV2F : public ::Value { | ||
158 | public: | ||
159 | V2F _0; | ||
160 | VV2F() { tag = tag::VV2F; } | ||
161 | }; | ||
162 | class VV3F : public ::Value { | ||
163 | public: | ||
164 | V3F _0; | ||
165 | VV3F() { tag = tag::VV3F; } | ||
166 | }; | ||
167 | class VV4F : public ::Value { | ||
168 | public: | ||
169 | V4F _0; | ||
170 | VV4F() { tag = tag::VV4F; } | ||
171 | }; | ||
172 | class VM22F : public ::Value { | ||
173 | public: | ||
174 | M22F _0; | ||
175 | VM22F() { tag = tag::VM22F; } | ||
176 | }; | ||
177 | class VM23F : public ::Value { | ||
178 | public: | ||
179 | M23F _0; | ||
180 | VM23F() { tag = tag::VM23F; } | ||
181 | }; | ||
182 | class VM24F : public ::Value { | ||
183 | public: | ||
184 | M24F _0; | ||
185 | VM24F() { tag = tag::VM24F; } | ||
186 | }; | ||
187 | class VM32F : public ::Value { | ||
188 | public: | ||
189 | M32F _0; | ||
190 | VM32F() { tag = tag::VM32F; } | ||
191 | }; | ||
192 | class VM33F : public ::Value { | ||
193 | public: | ||
194 | M33F _0; | ||
195 | VM33F() { tag = tag::VM33F; } | ||
196 | }; | ||
197 | class VM34F : public ::Value { | ||
198 | public: | ||
199 | M34F _0; | ||
200 | VM34F() { tag = tag::VM34F; } | ||
201 | }; | ||
202 | class VM42F : public ::Value { | ||
203 | public: | ||
204 | M42F _0; | ||
205 | VM42F() { tag = tag::VM42F; } | ||
206 | }; | ||
207 | class VM43F : public ::Value { | ||
208 | public: | ||
209 | M43F _0; | ||
210 | VM43F() { tag = tag::VM43F; } | ||
211 | }; | ||
212 | class VM44F : public ::Value { | ||
213 | public: | ||
214 | M44F _0; | ||
215 | VM44F() { tag = tag::VM44F; } | ||
216 | }; | ||
217 | } | ||
218 | class InputType { | ||
219 | public: | ||
220 | enum class tag { | ||
221 | Bool, | ||
222 | V2B, | ||
223 | V3B, | ||
224 | V4B, | ||
225 | Word, | ||
226 | V2U, | ||
227 | V3U, | ||
228 | V4U, | ||
229 | Int, | ||
230 | V2I, | ||
231 | V3I, | ||
232 | V4I, | ||
233 | Float, | ||
234 | V2F, | ||
235 | V3F, | ||
236 | V4F, | ||
237 | M22F, | ||
238 | M23F, | ||
239 | M24F, | ||
240 | M32F, | ||
241 | M33F, | ||
242 | M34F, | ||
243 | M42F, | ||
244 | M43F, | ||
245 | M44F, | ||
246 | STexture1D, | ||
247 | STexture2D, | ||
248 | STextureCube, | ||
249 | STexture1DArray, | ||
250 | STexture2DArray, | ||
251 | STexture2DRect, | ||
252 | FTexture1D, | ||
253 | FTexture2D, | ||
254 | FTexture3D, | ||
255 | FTextureCube, | ||
256 | FTexture1DArray, | ||
257 | FTexture2DArray, | ||
258 | FTexture2DMS, | ||
259 | FTexture2DMSArray, | ||
260 | FTextureBuffer, | ||
261 | FTexture2DRect, | ||
262 | ITexture1D, | ||
263 | ITexture2D, | ||
264 | ITexture3D, | ||
265 | ITextureCube, | ||
266 | ITexture1DArray, | ||
267 | ITexture2DArray, | ||
268 | ITexture2DMS, | ||
269 | ITexture2DMSArray, | ||
270 | ITextureBuffer, | ||
271 | ITexture2DRect, | ||
272 | UTexture1D, | ||
273 | UTexture2D, | ||
274 | UTexture3D, | ||
275 | UTextureCube, | ||
276 | UTexture1DArray, | ||
277 | UTexture2DArray, | ||
278 | UTexture2DMS, | ||
279 | UTexture2DMSArray, | ||
280 | UTextureBuffer, | ||
281 | UTexture2DRect | ||
282 | } tag; | ||
283 | }; | ||
284 | namespace data { | ||
285 | } | ||
286 | class PointSpriteCoordOrigin { | ||
287 | public: | ||
288 | enum class tag { | ||
289 | LowerLeft, | ||
290 | UpperLeft | ||
291 | } tag; | ||
292 | }; | ||
293 | namespace data { | ||
294 | } | ||
295 | class PointSize { | ||
296 | public: | ||
297 | enum class tag { | ||
298 | PointSize, | ||
299 | ProgramPointSize | ||
300 | } tag; | ||
301 | }; | ||
302 | namespace data { | ||
303 | class PointSize : public ::PointSize { | ||
304 | public: | ||
305 | Float _0; | ||
306 | PointSize() { tag = tag::PointSize; } | ||
307 | }; | ||
308 | } | ||
309 | class PolygonOffset { | ||
310 | public: | ||
311 | enum class tag { | ||
312 | NoOffset, | ||
313 | Offset | ||
314 | } tag; | ||
315 | }; | ||
316 | namespace data { | ||
317 | class Offset : public ::PolygonOffset { | ||
318 | public: | ||
319 | Float _0; | ||
320 | Float _1; | ||
321 | Offset() { tag = tag::Offset; } | ||
322 | }; | ||
323 | } | ||
324 | class FrontFace { | ||
325 | public: | ||
326 | enum class tag { | ||
327 | CCW, | ||
328 | CW | ||
329 | } tag; | ||
330 | }; | ||
331 | namespace data { | ||
332 | } | ||
333 | class PolygonMode { | ||
334 | public: | ||
335 | enum class tag { | ||
336 | PolygonPoint, | ||
337 | PolygonLine, | ||
338 | PolygonFill | ||
339 | } tag; | ||
340 | }; | ||
341 | namespace data { | ||
342 | class PolygonPoint : public ::PolygonMode { | ||
343 | public: | ||
344 | std::shared_ptr<::PointSize> _0; | ||
345 | PolygonPoint() { tag = tag::PolygonPoint; } | ||
346 | }; | ||
347 | class PolygonLine : public ::PolygonMode { | ||
348 | public: | ||
349 | Float _0; | ||
350 | PolygonLine() { tag = tag::PolygonLine; } | ||
351 | }; | ||
352 | } | ||
353 | class ProvokingVertex { | ||
354 | public: | ||
355 | enum class tag { | ||
356 | FirstVertex, | ||
357 | LastVertex | ||
358 | } tag; | ||
359 | }; | ||
360 | namespace data { | ||
361 | } | ||
362 | class CullMode { | ||
363 | public: | ||
364 | enum class tag { | ||
365 | CullNone, | ||
366 | CullFront, | ||
367 | CullBack | ||
368 | } tag; | ||
369 | }; | ||
370 | namespace data { | ||
371 | class CullFront : public ::CullMode { | ||
372 | public: | ||
373 | std::shared_ptr<::FrontFace> _0; | ||
374 | CullFront() { tag = tag::CullFront; } | ||
375 | }; | ||
376 | class CullBack : public ::CullMode { | ||
377 | public: | ||
378 | std::shared_ptr<::FrontFace> _0; | ||
379 | CullBack() { tag = tag::CullBack; } | ||
380 | }; | ||
381 | } | ||
382 | class ComparisonFunction { | ||
383 | public: | ||
384 | enum class tag { | ||
385 | Never, | ||
386 | Less, | ||
387 | Equal, | ||
388 | Lequal, | ||
389 | Greater, | ||
390 | Notequal, | ||
391 | Gequal, | ||
392 | Always | ||
393 | } tag; | ||
394 | }; | ||
395 | namespace data { | ||
396 | } | ||
397 | typedef ComparisonFunction DepthFunction; | ||
398 | |||
399 | class StencilOperation { | ||
400 | public: | ||
401 | enum class tag { | ||
402 | OpZero, | ||
403 | OpKeep, | ||
404 | OpReplace, | ||
405 | OpIncr, | ||
406 | OpIncrWrap, | ||
407 | OpDecr, | ||
408 | OpDecrWrap, | ||
409 | OpInvert | ||
410 | } tag; | ||
411 | }; | ||
412 | namespace data { | ||
413 | } | ||
414 | class BlendEquation { | ||
415 | public: | ||
416 | enum class tag { | ||
417 | FuncAdd, | ||
418 | FuncSubtract, | ||
419 | FuncReverseSubtract, | ||
420 | Min, | ||
421 | Max | ||
422 | } tag; | ||
423 | }; | ||
424 | namespace data { | ||
425 | } | ||
426 | class BlendingFactor { | ||
427 | public: | ||
428 | enum class tag { | ||
429 | Zero, | ||
430 | One, | ||
431 | SrcColor, | ||
432 | OneMinusSrcColor, | ||
433 | DstColor, | ||
434 | OneMinusDstColor, | ||
435 | SrcAlpha, | ||
436 | OneMinusSrcAlpha, | ||
437 | DstAlpha, | ||
438 | OneMinusDstAlpha, | ||
439 | ConstantColor, | ||
440 | OneMinusConstantColor, | ||
441 | ConstantAlpha, | ||
442 | OneMinusConstantAlpha, | ||
443 | SrcAlphaSaturate | ||
444 | } tag; | ||
445 | }; | ||
446 | namespace data { | ||
447 | } | ||
448 | class LogicOperation { | ||
449 | public: | ||
450 | enum class tag { | ||
451 | Clear, | ||
452 | And, | ||
453 | AndReverse, | ||
454 | Copy, | ||
455 | AndInverted, | ||
456 | Noop, | ||
457 | Xor, | ||
458 | Or, | ||
459 | Nor, | ||
460 | Equiv, | ||
461 | Invert, | ||
462 | OrReverse, | ||
463 | CopyInverted, | ||
464 | OrInverted, | ||
465 | Nand, | ||
466 | Set | ||
467 | } tag; | ||
468 | }; | ||
469 | namespace data { | ||
470 | } | ||
471 | class StencilOps { | ||
472 | public: | ||
473 | enum class tag { | ||
474 | StencilOps | ||
475 | } tag; | ||
476 | }; | ||
477 | namespace data { | ||
478 | class StencilOps : public ::StencilOps { | ||
479 | public: | ||
480 | std::shared_ptr<::StencilOperation> frontStencilOp; | ||
481 | std::shared_ptr<::StencilOperation> backStencilOp; | ||
482 | StencilOps() { tag = tag::StencilOps; } | ||
483 | }; | ||
484 | } | ||
485 | class StencilTest { | ||
486 | public: | ||
487 | enum class tag { | ||
488 | StencilTest | ||
489 | } tag; | ||
490 | }; | ||
491 | namespace data { | ||
492 | class StencilTest : public ::StencilTest { | ||
493 | public: | ||
494 | std::shared_ptr<::ComparisonFunction> stencilComparision; | ||
495 | Int32 stencilReference; | ||
496 | Word32 stencilMask; | ||
497 | StencilTest() { tag = tag::StencilTest; } | ||
498 | }; | ||
499 | } | ||
500 | class StencilTests { | ||
501 | public: | ||
502 | enum class tag { | ||
503 | StencilTests | ||
504 | } tag; | ||
505 | }; | ||
506 | namespace data { | ||
507 | class StencilTests : public ::StencilTests { | ||
508 | public: | ||
509 | std::shared_ptr<::StencilTest> _0; | ||
510 | std::shared_ptr<::StencilTest> _1; | ||
511 | StencilTests() { tag = tag::StencilTests; } | ||
512 | }; | ||
513 | } | ||
514 | class FetchPrimitive { | ||
515 | public: | ||
516 | enum class tag { | ||
517 | Points, | ||
518 | Lines, | ||
519 | Triangles, | ||
520 | LinesAdjacency, | ||
521 | TrianglesAdjacency | ||
522 | } tag; | ||
523 | }; | ||
524 | namespace data { | ||
525 | } | ||
526 | class OutputPrimitive { | ||
527 | public: | ||
528 | enum class tag { | ||
529 | TrianglesOutput, | ||
530 | LinesOutput, | ||
531 | PointsOutput | ||
532 | } tag; | ||
533 | }; | ||
534 | namespace data { | ||
535 | } | ||
536 | class ColorArity { | ||
537 | public: | ||
538 | enum class tag { | ||
539 | Red, | ||
540 | RG, | ||
541 | RGB, | ||
542 | RGBA | ||
543 | } tag; | ||
544 | }; | ||
545 | namespace data { | ||
546 | } | ||
547 | class Blending { | ||
548 | public: | ||
549 | enum class tag { | ||
550 | NoBlending, | ||
551 | BlendLogicOp, | ||
552 | Blend | ||
553 | } tag; | ||
554 | }; | ||
555 | namespace data { | ||
556 | class BlendLogicOp : public ::Blending { | ||
557 | public: | ||
558 | std::shared_ptr<::LogicOperation> _0; | ||
559 | BlendLogicOp() { tag = tag::BlendLogicOp; } | ||
560 | }; | ||
561 | class Blend : public ::Blending { | ||
562 | public: | ||
563 | std::shared_ptr<::BlendEquation> colorEqSrc; | ||
564 | std::shared_ptr<::BlendEquation> alphaEqSrc; | ||
565 | std::shared_ptr<::BlendingFactor> colorFSrc; | ||
566 | std::shared_ptr<::BlendingFactor> colorFDst; | ||
567 | std::shared_ptr<::BlendingFactor> alphaFSrc; | ||
568 | std::shared_ptr<::BlendingFactor> alphaFDst; | ||
569 | V4F color; | ||
570 | Blend() { tag = tag::Blend; } | ||
571 | }; | ||
572 | } | ||
573 | class RasterContext { | ||
574 | public: | ||
575 | enum class tag { | ||
576 | PointCtx, | ||
577 | LineCtx, | ||
578 | TriangleCtx | ||
579 | } tag; | ||
580 | }; | ||
581 | namespace data { | ||
582 | class PointCtx : public ::RasterContext { | ||
583 | public: | ||
584 | std::shared_ptr<::PointSize> _0; | ||
585 | Float _1; | ||
586 | std::shared_ptr<::PointSpriteCoordOrigin> _2; | ||
587 | PointCtx() { tag = tag::PointCtx; } | ||
588 | }; | ||
589 | class LineCtx : public ::RasterContext { | ||
590 | public: | ||
591 | Float _0; | ||
592 | std::shared_ptr<::ProvokingVertex> _1; | ||
593 | LineCtx() { tag = tag::LineCtx; } | ||
594 | }; | ||
595 | class TriangleCtx : public ::RasterContext { | ||
596 | public: | ||
597 | std::shared_ptr<::CullMode> _0; | ||
598 | std::shared_ptr<::PolygonMode> _1; | ||
599 | std::shared_ptr<::PolygonOffset> _2; | ||
600 | std::shared_ptr<::ProvokingVertex> _3; | ||
601 | TriangleCtx() { tag = tag::TriangleCtx; } | ||
602 | }; | ||
603 | } | ||
604 | class FragmentOperation { | ||
605 | public: | ||
606 | enum class tag { | ||
607 | DepthOp, | ||
608 | StencilOp, | ||
609 | ColorOp | ||
610 | } tag; | ||
611 | }; | ||
612 | namespace data { | ||
613 | class DepthOp : public ::FragmentOperation { | ||
614 | public: | ||
615 | std::shared_ptr<::DepthFunction> _0; | ||
616 | Bool _1; | ||
617 | DepthOp() { tag = tag::DepthOp; } | ||
618 | }; | ||
619 | class StencilOp : public ::FragmentOperation { | ||
620 | public: | ||
621 | std::shared_ptr<::StencilTests> _0; | ||
622 | std::shared_ptr<::StencilOps> _1; | ||
623 | std::shared_ptr<::StencilOps> _2; | ||
624 | StencilOp() { tag = tag::StencilOp; } | ||
625 | }; | ||
626 | class ColorOp : public ::FragmentOperation { | ||
627 | public: | ||
628 | std::shared_ptr<::Blending> _0; | ||
629 | std::shared_ptr<::Value> _1; | ||
630 | ColorOp() { tag = tag::ColorOp; } | ||
631 | }; | ||
632 | } | ||
633 | class AccumulationContext { | ||
634 | public: | ||
635 | enum class tag { | ||
636 | AccumulationContext | ||
637 | } tag; | ||
638 | }; | ||
639 | namespace data { | ||
640 | class AccumulationContext : public ::AccumulationContext { | ||
641 | public: | ||
642 | Maybe<String> accViewportName; | ||
643 | std::vector<std::shared_ptr<::FragmentOperation>> accOperations; | ||
644 | AccumulationContext() { tag = tag::AccumulationContext; } | ||
645 | }; | ||
646 | } | ||
647 | class TextureDataType { | ||
648 | public: | ||
649 | enum class tag { | ||
650 | FloatT, | ||
651 | IntT, | ||
652 | WordT, | ||
653 | ShadowT | ||
654 | } tag; | ||
655 | }; | ||
656 | namespace data { | ||
657 | class FloatT : public ::TextureDataType { | ||
658 | public: | ||
659 | std::shared_ptr<::ColorArity> _0; | ||
660 | FloatT() { tag = tag::FloatT; } | ||
661 | }; | ||
662 | class IntT : public ::TextureDataType { | ||
663 | public: | ||
664 | std::shared_ptr<::ColorArity> _0; | ||
665 | IntT() { tag = tag::IntT; } | ||
666 | }; | ||
667 | class WordT : public ::TextureDataType { | ||
668 | public: | ||
669 | std::shared_ptr<::ColorArity> _0; | ||
670 | WordT() { tag = tag::WordT; } | ||
671 | }; | ||
672 | } | ||
673 | class TextureType { | ||
674 | public: | ||
675 | enum class tag { | ||
676 | Texture1D, | ||
677 | Texture2D, | ||
678 | Texture3D, | ||
679 | TextureCube, | ||
680 | TextureRect, | ||
681 | Texture2DMS, | ||
682 | TextureBuffer | ||
683 | } tag; | ||
684 | }; | ||
685 | namespace data { | ||
686 | class Texture1D : public ::TextureType { | ||
687 | public: | ||
688 | std::shared_ptr<::TextureDataType> _0; | ||
689 | Int _1; | ||
690 | Texture1D() { tag = tag::Texture1D; } | ||
691 | }; | ||
692 | class Texture2D : public ::TextureType { | ||
693 | public: | ||
694 | std::shared_ptr<::TextureDataType> _0; | ||
695 | Int _1; | ||
696 | Texture2D() { tag = tag::Texture2D; } | ||
697 | }; | ||
698 | class Texture3D : public ::TextureType { | ||
699 | public: | ||
700 | std::shared_ptr<::TextureDataType> _0; | ||
701 | Texture3D() { tag = tag::Texture3D; } | ||
702 | }; | ||
703 | class TextureCube : public ::TextureType { | ||
704 | public: | ||
705 | std::shared_ptr<::TextureDataType> _0; | ||
706 | TextureCube() { tag = tag::TextureCube; } | ||
707 | }; | ||
708 | class TextureRect : public ::TextureType { | ||
709 | public: | ||
710 | std::shared_ptr<::TextureDataType> _0; | ||
711 | TextureRect() { tag = tag::TextureRect; } | ||
712 | }; | ||
713 | class Texture2DMS : public ::TextureType { | ||
714 | public: | ||
715 | std::shared_ptr<::TextureDataType> _0; | ||
716 | Int _1; | ||
717 | Int _2; | ||
718 | Bool _3; | ||
719 | Texture2DMS() { tag = tag::Texture2DMS; } | ||
720 | }; | ||
721 | class TextureBuffer : public ::TextureType { | ||
722 | public: | ||
723 | std::shared_ptr<::TextureDataType> _0; | ||
724 | TextureBuffer() { tag = tag::TextureBuffer; } | ||
725 | }; | ||
726 | } | ||
727 | class MipMap { | ||
728 | public: | ||
729 | enum class tag { | ||
730 | Mip, | ||
731 | NoMip, | ||
732 | AutoMip | ||
733 | } tag; | ||
734 | }; | ||
735 | namespace data { | ||
736 | class Mip : public ::MipMap { | ||
737 | public: | ||
738 | Int _0; | ||
739 | Int _1; | ||
740 | Mip() { tag = tag::Mip; } | ||
741 | }; | ||
742 | class AutoMip : public ::MipMap { | ||
743 | public: | ||
744 | Int _0; | ||
745 | Int _1; | ||
746 | AutoMip() { tag = tag::AutoMip; } | ||
747 | }; | ||
748 | } | ||
749 | class Filter { | ||
750 | public: | ||
751 | enum class tag { | ||
752 | Nearest, | ||
753 | Linear, | ||
754 | NearestMipmapNearest, | ||
755 | NearestMipmapLinear, | ||
756 | LinearMipmapNearest, | ||
757 | LinearMipmapLinear | ||
758 | } tag; | ||
759 | }; | ||
760 | namespace data { | ||
761 | } | ||
762 | class EdgeMode { | ||
763 | public: | ||
764 | enum class tag { | ||
765 | Repeat, | ||
766 | MirroredRepeat, | ||
767 | ClampToEdge, | ||
768 | ClampToBorder | ||
769 | } tag; | ||
770 | }; | ||
771 | namespace data { | ||
772 | } | ||
773 | class ImageSemantic { | ||
774 | public: | ||
775 | enum class tag { | ||
776 | Depth, | ||
777 | Stencil, | ||
778 | Color | ||
779 | } tag; | ||
780 | }; | ||
781 | namespace data { | ||
782 | } | ||
783 | class ImageRef { | ||
784 | public: | ||
785 | enum class tag { | ||
786 | TextureImage, | ||
787 | Framebuffer | ||
788 | } tag; | ||
789 | }; | ||
790 | namespace data { | ||
791 | class TextureImage : public ::ImageRef { | ||
792 | public: | ||
793 | ::TextureName _0; | ||
794 | Int _1; | ||
795 | Maybe<Int> _2; | ||
796 | TextureImage() { tag = tag::TextureImage; } | ||
797 | }; | ||
798 | class Framebuffer : public ::ImageRef { | ||
799 | public: | ||
800 | std::shared_ptr<::ImageSemantic> _0; | ||
801 | Framebuffer() { tag = tag::Framebuffer; } | ||
802 | }; | ||
803 | } | ||
804 | class ClearImage { | ||
805 | public: | ||
806 | enum class tag { | ||
807 | ClearImage | ||
808 | } tag; | ||
809 | }; | ||
810 | namespace data { | ||
811 | class ClearImage : public ::ClearImage { | ||
812 | public: | ||
813 | std::shared_ptr<::ImageSemantic> imageSemantic; | ||
814 | std::shared_ptr<::Value> clearValue; | ||
815 | ClearImage() { tag = tag::ClearImage; } | ||
816 | }; | ||
817 | } | ||
818 | class Command { | ||
819 | public: | ||
820 | enum class tag { | ||
821 | SetRasterContext, | ||
822 | SetAccumulationContext, | ||
823 | SetRenderTarget, | ||
824 | SetProgram, | ||
825 | SetSamplerUniform, | ||
826 | SetTexture, | ||
827 | SetSampler, | ||
828 | RenderSlot, | ||
829 | RenderStream, | ||
830 | ClearRenderTarget, | ||
831 | GenerateMipMap, | ||
832 | SaveImage, | ||
833 | LoadImage | ||
834 | } tag; | ||
835 | }; | ||
836 | namespace data { | ||
837 | class SetRasterContext : public ::Command { | ||
838 | public: | ||
839 | std::shared_ptr<::RasterContext> _0; | ||
840 | SetRasterContext() { tag = tag::SetRasterContext; } | ||
841 | }; | ||
842 | class SetAccumulationContext : public ::Command { | ||
843 | public: | ||
844 | std::shared_ptr<::AccumulationContext> _0; | ||
845 | SetAccumulationContext() { tag = tag::SetAccumulationContext; } | ||
846 | }; | ||
847 | class SetRenderTarget : public ::Command { | ||
848 | public: | ||
849 | ::RenderTargetName _0; | ||
850 | SetRenderTarget() { tag = tag::SetRenderTarget; } | ||
851 | }; | ||
852 | class SetProgram : public ::Command { | ||
853 | public: | ||
854 | ::ProgramName _0; | ||
855 | SetProgram() { tag = tag::SetProgram; } | ||
856 | }; | ||
857 | class SetSamplerUniform : public ::Command { | ||
858 | public: | ||
859 | ::UniformName _0; | ||
860 | ::TextureUnit _1; | ||
861 | SetSamplerUniform() { tag = tag::SetSamplerUniform; } | ||
862 | }; | ||
863 | class SetTexture : public ::Command { | ||
864 | public: | ||
865 | ::TextureUnit _0; | ||
866 | ::TextureName _1; | ||
867 | SetTexture() { tag = tag::SetTexture; } | ||
868 | }; | ||
869 | class SetSampler : public ::Command { | ||
870 | public: | ||
871 | ::TextureUnit _0; | ||
872 | Maybe<::SamplerName> _1; | ||
873 | SetSampler() { tag = tag::SetSampler; } | ||
874 | }; | ||
875 | class RenderSlot : public ::Command { | ||
876 | public: | ||
877 | ::SlotName _0; | ||
878 | RenderSlot() { tag = tag::RenderSlot; } | ||
879 | }; | ||
880 | class RenderStream : public ::Command { | ||
881 | public: | ||
882 | ::StreamName _0; | ||
883 | RenderStream() { tag = tag::RenderStream; } | ||
884 | }; | ||
885 | class ClearRenderTarget : public ::Command { | ||
886 | public: | ||
887 | std::vector<std::shared_ptr<::ClearImage>> _0; | ||
888 | ClearRenderTarget() { tag = tag::ClearRenderTarget; } | ||
889 | }; | ||
890 | class GenerateMipMap : public ::Command { | ||
891 | public: | ||
892 | ::TextureUnit _0; | ||
893 | GenerateMipMap() { tag = tag::GenerateMipMap; } | ||
894 | }; | ||
895 | class SaveImage : public ::Command { | ||
896 | public: | ||
897 | ::FrameBufferComponent _0; | ||
898 | std::shared_ptr<::ImageRef> _1; | ||
899 | SaveImage() { tag = tag::SaveImage; } | ||
900 | }; | ||
901 | class LoadImage : public ::Command { | ||
902 | public: | ||
903 | std::shared_ptr<::ImageRef> _0; | ||
904 | ::FrameBufferComponent _1; | ||
905 | LoadImage() { tag = tag::LoadImage; } | ||
906 | }; | ||
907 | } | ||
908 | class SamplerDescriptor { | ||
909 | public: | ||
910 | enum class tag { | ||
911 | SamplerDescriptor | ||
912 | } tag; | ||
913 | }; | ||
914 | namespace data { | ||
915 | class SamplerDescriptor : public ::SamplerDescriptor { | ||
916 | public: | ||
917 | std::shared_ptr<::EdgeMode> samplerWrapS; | ||
918 | Maybe<std::shared_ptr<::EdgeMode>> samplerWrapT; | ||
919 | Maybe<std::shared_ptr<::EdgeMode>> samplerWrapR; | ||
920 | std::shared_ptr<::Filter> samplerMinFilter; | ||
921 | std::shared_ptr<::Filter> samplerMagFilter; | ||
922 | std::shared_ptr<::Value> samplerBorderColor; | ||
923 | Maybe<Float> samplerMinLod; | ||
924 | Maybe<Float> samplerMaxLod; | ||
925 | Float samplerLodBias; | ||
926 | Maybe<std::shared_ptr<::ComparisonFunction>> samplerCompareFunc; | ||
927 | SamplerDescriptor() { tag = tag::SamplerDescriptor; } | ||
928 | }; | ||
929 | } | ||
930 | class TextureDescriptor { | ||
931 | public: | ||
932 | enum class tag { | ||
933 | TextureDescriptor | ||
934 | } tag; | ||
935 | }; | ||
936 | namespace data { | ||
937 | class TextureDescriptor : public ::TextureDescriptor { | ||
938 | public: | ||
939 | std::shared_ptr<::TextureType> textureType; | ||
940 | std::shared_ptr<::Value> textureSize; | ||
941 | std::shared_ptr<::ImageSemantic> textureSemantic; | ||
942 | std::shared_ptr<::SamplerDescriptor> textureSampler; | ||
943 | Int textureBaseLevel; | ||
944 | Int textureMaxLevel; | ||
945 | TextureDescriptor() { tag = tag::TextureDescriptor; } | ||
946 | }; | ||
947 | } | ||
948 | class Parameter { | ||
949 | public: | ||
950 | enum class tag { | ||
951 | Parameter | ||
952 | } tag; | ||
953 | }; | ||
954 | namespace data { | ||
955 | class Parameter : public ::Parameter { | ||
956 | public: | ||
957 | String name; | ||
958 | std::shared_ptr<::InputType> ty; | ||
959 | Parameter() { tag = tag::Parameter; } | ||
960 | }; | ||
961 | } | ||
962 | class Program { | ||
963 | public: | ||
964 | enum class tag { | ||
965 | Program | ||
966 | } tag; | ||
967 | }; | ||
968 | namespace data { | ||
969 | class Program : public ::Program { | ||
970 | public: | ||
971 | std::map<::UniformName, std::shared_ptr<::InputType>> programUniforms; | ||
972 | std::map<::UniformName, std::shared_ptr<::Parameter>> programStreams; | ||
973 | std::map<::UniformName, std::shared_ptr<::InputType>> programInTextures; | ||
974 | std::vector<std::shared_ptr<::Parameter>> programOutput; | ||
975 | String vertexShader; | ||
976 | Maybe<String> geometryShader; | ||
977 | String fragmentShader; | ||
978 | Program() { tag = tag::Program; } | ||
979 | }; | ||
980 | } | ||
981 | class Slot { | ||
982 | public: | ||
983 | enum class tag { | ||
984 | Slot | ||
985 | } tag; | ||
986 | }; | ||
987 | namespace data { | ||
988 | class Slot : public ::Slot { | ||
989 | public: | ||
990 | String slotName; | ||
991 | std::map<String, std::shared_ptr<::InputType>> slotStreams; | ||
992 | std::map<::UniformName, std::shared_ptr<::InputType>> slotUniforms; | ||
993 | std::shared_ptr<::FetchPrimitive> slotPrimitive; | ||
994 | std::vector<::ProgramName> slotPrograms; | ||
995 | Slot() { tag = tag::Slot; } | ||
996 | }; | ||
997 | } | ||
998 | class StreamData { | ||
999 | public: | ||
1000 | enum class tag { | ||
1001 | StreamData | ||
1002 | } tag; | ||
1003 | }; | ||
1004 | namespace data { | ||
1005 | class StreamData : public ::StreamData { | ||
1006 | public: | ||
1007 | std::map<String, std::shared_ptr<::ArrayValue>> streamData; | ||
1008 | std::map<String, std::shared_ptr<::InputType>> streamType; | ||
1009 | std::shared_ptr<::FetchPrimitive> streamPrimitive; | ||
1010 | std::vector<::ProgramName> streamPrograms; | ||
1011 | StreamData() { tag = tag::StreamData; } | ||
1012 | }; | ||
1013 | } | ||
1014 | class TargetItem { | ||
1015 | public: | ||
1016 | enum class tag { | ||
1017 | TargetItem | ||
1018 | } tag; | ||
1019 | }; | ||
1020 | namespace data { | ||
1021 | class TargetItem : public ::TargetItem { | ||
1022 | public: | ||
1023 | std::shared_ptr<::ImageSemantic> targetSemantic; | ||
1024 | Maybe<std::shared_ptr<::ImageRef>> targetRef; | ||
1025 | TargetItem() { tag = tag::TargetItem; } | ||
1026 | }; | ||
1027 | } | ||
1028 | class RenderTarget { | ||
1029 | public: | ||
1030 | enum class tag { | ||
1031 | RenderTarget | ||
1032 | } tag; | ||
1033 | }; | ||
1034 | namespace data { | ||
1035 | class RenderTarget : public ::RenderTarget { | ||
1036 | public: | ||
1037 | std::vector<std::shared_ptr<::TargetItem>> renderTargets; | ||
1038 | RenderTarget() { tag = tag::RenderTarget; } | ||
1039 | }; | ||
1040 | } | ||
1041 | class Backend { | ||
1042 | public: | ||
1043 | enum class tag { | ||
1044 | WebGL1, | ||
1045 | OpenGL33 | ||
1046 | } tag; | ||
1047 | }; | ||
1048 | namespace data { | ||
1049 | } | ||
1050 | class Pipeline { | ||
1051 | public: | ||
1052 | enum class tag { | ||
1053 | Pipeline | ||
1054 | } tag; | ||
1055 | }; | ||
1056 | namespace data { | ||
1057 | class Pipeline : public ::Pipeline { | ||
1058 | public: | ||
1059 | std::shared_ptr<::Backend> backend; | ||
1060 | std::vector<std::shared_ptr<::TextureDescriptor>> textures; | ||
1061 | std::vector<std::shared_ptr<::SamplerDescriptor>> samplers; | ||
1062 | std::vector<std::shared_ptr<::RenderTarget>> targets; | ||
1063 | std::vector<std::shared_ptr<::Program>> programs; | ||
1064 | std::vector<std::shared_ptr<::Slot>> slots; | ||
1065 | std::vector<std::shared_ptr<::StreamData>> streams; | ||
1066 | std::vector<std::shared_ptr<::Command>> commands; | ||
1067 | Pipeline() { tag = tag::Pipeline; } | ||
1068 | }; | ||
1069 | } | ||
1070 | #endif | ||