1 files changed, 1070 insertions, 0 deletions

diff --git a/ddl/out/LambdaCube.IR.hpp b/ddl/out/LambdaCube.IR.hpp
new file mode 100644
index 0000000..c45d1ce
--- /dev/null
+++ b/ddl/out/LambdaCube.IR.hpp
@@ -0,0 +1,1070 @@
+// generated file, do not modify!
+// 2016-01-28T13:15:30.803775Z
+
+#ifndef HEADER_LambdaCube.IR_H
+#define HEADER_LambdaCube.IR_H
+
+#include "RT.hpp"
+
+
+typedef Int StreamName;
+
+typedef Int ProgramName;
+
+typedef Int TextureName;
+
+typedef Int SamplerName;
+
+typedef String UniformName;
+
+typedef Int SlotName;
+
+typedef Int FrameBufferComponent;
+
+typedef Int TextureUnit;
+
+typedef Int RenderTargetName;
+
+typedef std::map<::UniformName, ::TextureUnit> TextureUnitMapping;
+
+class ArrayValue {
+  public:
+    enum class tag { 
+      VBoolArray,
+      VIntArray,
+      VWordArray,
+      VFloatArray
+    } tag;
+};
+namespace data { 
+  class VBoolArray : public ::ArrayValue {
+    public:
+      std::vector<Bool> _0;
+      VBoolArray() { tag = tag::VBoolArray; }
+  };
+  class VIntArray : public ::ArrayValue {
+    public:
+      std::vector<Int32> _0;
+      VIntArray() { tag = tag::VIntArray; }
+  };
+  class VWordArray : public ::ArrayValue {
+    public:
+      std::vector<Word32> _0;
+      VWordArray() { tag = tag::VWordArray; }
+  };
+  class VFloatArray : public ::ArrayValue {
+    public:
+      std::vector<Float> _0;
+      VFloatArray() { tag = tag::VFloatArray; }
+  };
+}
+class Value {
+  public:
+    enum class tag { 
+      VBool,
+      VV2B,
+      VV3B,
+      VV4B,
+      VWord,
+      VV2U,
+      VV3U,
+      VV4U,
+      VInt,
+      VV2I,
+      VV3I,
+      VV4I,
+      VFloat,
+      VV2F,
+      VV3F,
+      VV4F,
+      VM22F,
+      VM23F,
+      VM24F,
+      VM32F,
+      VM33F,
+      VM34F,
+      VM42F,
+      VM43F,
+      VM44F
+    } tag;
+};
+namespace data { 
+  class VBool : public ::Value {
+    public:
+      Bool _0;
+      VBool() { tag = tag::VBool; }
+  };
+  class VV2B : public ::Value {
+    public:
+      V2B _0;
+      VV2B() { tag = tag::VV2B; }
+  };
+  class VV3B : public ::Value {
+    public:
+      V3B _0;
+      VV3B() { tag = tag::VV3B; }
+  };
+  class VV4B : public ::Value {
+    public:
+      V4B _0;
+      VV4B() { tag = tag::VV4B; }
+  };
+  class VWord : public ::Value {
+    public:
+      Word32 _0;
+      VWord() { tag = tag::VWord; }
+  };
+  class VV2U : public ::Value {
+    public:
+      V2U _0;
+      VV2U() { tag = tag::VV2U; }
+  };
+  class VV3U : public ::Value {
+    public:
+      V3U _0;
+      VV3U() { tag = tag::VV3U; }
+  };
+  class VV4U : public ::Value {
+    public:
+      V4U _0;
+      VV4U() { tag = tag::VV4U; }
+  };
+  class VInt : public ::Value {
+    public:
+      Int32 _0;
+      VInt() { tag = tag::VInt; }
+  };
+  class VV2I : public ::Value {
+    public:
+      V2I _0;
+      VV2I() { tag = tag::VV2I; }
+  };
+  class VV3I : public ::Value {
+    public:
+      V3I _0;
+      VV3I() { tag = tag::VV3I; }
+  };
+  class VV4I : public ::Value {
+    public:
+      V4I _0;
+      VV4I() { tag = tag::VV4I; }
+  };
+  class VFloat : public ::Value {
+    public:
+      Float _0;
+      VFloat() { tag = tag::VFloat; }
+  };
+  class VV2F : public ::Value {
+    public:
+      V2F _0;
+      VV2F() { tag = tag::VV2F; }
+  };
+  class VV3F : public ::Value {
+    public:
+      V3F _0;
+      VV3F() { tag = tag::VV3F; }
+  };
+  class VV4F : public ::Value {
+    public:
+      V4F _0;
+      VV4F() { tag = tag::VV4F; }
+  };
+  class VM22F : public ::Value {
+    public:
+      M22F _0;
+      VM22F() { tag = tag::VM22F; }
+  };
+  class VM23F : public ::Value {
+    public:
+      M23F _0;
+      VM23F() { tag = tag::VM23F; }
+  };
+  class VM24F : public ::Value {
+    public:
+      M24F _0;
+      VM24F() { tag = tag::VM24F; }
+  };
+  class VM32F : public ::Value {
+    public:
+      M32F _0;
+      VM32F() { tag = tag::VM32F; }
+  };
+  class VM33F : public ::Value {
+    public:
+      M33F _0;
+      VM33F() { tag = tag::VM33F; }
+  };
+  class VM34F : public ::Value {
+    public:
+      M34F _0;
+      VM34F() { tag = tag::VM34F; }
+  };
+  class VM42F : public ::Value {
+    public:
+      M42F _0;
+      VM42F() { tag = tag::VM42F; }
+  };
+  class VM43F : public ::Value {
+    public:
+      M43F _0;
+      VM43F() { tag = tag::VM43F; }
+  };
+  class VM44F : public ::Value {
+    public:
+      M44F _0;
+      VM44F() { tag = tag::VM44F; }
+  };
+}
+class InputType {
+  public:
+    enum class tag { 
+      Bool,
+      V2B,
+      V3B,
+      V4B,
+      Word,
+      V2U,
+      V3U,
+      V4U,
+      Int,
+      V2I,
+      V3I,
+      V4I,
+      Float,
+      V2F,
+      V3F,
+      V4F,
+      M22F,
+      M23F,
+      M24F,
+      M32F,
+      M33F,
+      M34F,
+      M42F,
+      M43F,
+      M44F,
+      STexture1D,
+      STexture2D,
+      STextureCube,
+      STexture1DArray,
+      STexture2DArray,
+      STexture2DRect,
+      FTexture1D,
+      FTexture2D,
+      FTexture3D,
+      FTextureCube,
+      FTexture1DArray,
+      FTexture2DArray,
+      FTexture2DMS,
+      FTexture2DMSArray,
+      FTextureBuffer,
+      FTexture2DRect,
+      ITexture1D,
+      ITexture2D,
+      ITexture3D,
+      ITextureCube,
+      ITexture1DArray,
+      ITexture2DArray,
+      ITexture2DMS,
+      ITexture2DMSArray,
+      ITextureBuffer,
+      ITexture2DRect,
+      UTexture1D,
+      UTexture2D,
+      UTexture3D,
+      UTextureCube,
+      UTexture1DArray,
+      UTexture2DArray,
+      UTexture2DMS,
+      UTexture2DMSArray,
+      UTextureBuffer,
+      UTexture2DRect
+    } tag;
+};
+namespace data { 
+}
+class PointSpriteCoordOrigin {
+  public:
+    enum class tag { 
+      LowerLeft,
+      UpperLeft
+    } tag;
+};
+namespace data { 
+}
+class PointSize {
+  public:
+    enum class tag { 
+      PointSize,
+      ProgramPointSize
+    } tag;
+};
+namespace data { 
+  class PointSize : public ::PointSize {
+    public:
+      Float _0;
+      PointSize() { tag = tag::PointSize; }
+  };
+}
+class PolygonOffset {
+  public:
+    enum class tag { 
+      NoOffset,
+      Offset
+    } tag;
+};
+namespace data { 
+  class Offset : public ::PolygonOffset {
+    public:
+      Float _0;
+      Float _1;
+      Offset() { tag = tag::Offset; }
+  };
+}
+class FrontFace {
+  public:
+    enum class tag { 
+      CCW,
+      CW
+    } tag;
+};
+namespace data { 
+}
+class PolygonMode {
+  public:
+    enum class tag { 
+      PolygonPoint,
+      PolygonLine,
+      PolygonFill
+    } tag;
+};
+namespace data { 
+  class PolygonPoint : public ::PolygonMode {
+    public:
+      std::shared_ptr<::PointSize> _0;
+      PolygonPoint() { tag = tag::PolygonPoint; }
+  };
+  class PolygonLine : public ::PolygonMode {
+    public:
+      Float _0;
+      PolygonLine() { tag = tag::PolygonLine; }
+  };
+}
+class ProvokingVertex {
+  public:
+    enum class tag { 
+      FirstVertex,
+      LastVertex
+    } tag;
+};
+namespace data { 
+}
+class CullMode {
+  public:
+    enum class tag { 
+      CullNone,
+      CullFront,
+      CullBack
+    } tag;
+};
+namespace data { 
+  class CullFront : public ::CullMode {
+    public:
+      std::shared_ptr<::FrontFace> _0;
+      CullFront() { tag = tag::CullFront; }
+  };
+  class CullBack : public ::CullMode {
+    public:
+      std::shared_ptr<::FrontFace> _0;
+      CullBack() { tag = tag::CullBack; }
+  };
+}
+class ComparisonFunction {
+  public:
+    enum class tag { 
+      Never,
+      Less,
+      Equal,
+      Lequal,
+      Greater,
+      Notequal,
+      Gequal,
+      Always
+    } tag;
+};
+namespace data { 
+}
+typedef ComparisonFunction DepthFunction;
+
+class StencilOperation {
+  public:
+    enum class tag { 
+      OpZero,
+      OpKeep,
+      OpReplace,
+      OpIncr,
+      OpIncrWrap,
+      OpDecr,
+      OpDecrWrap,
+      OpInvert
+    } tag;
+};
+namespace data { 
+}
+class BlendEquation {
+  public:
+    enum class tag { 
+      FuncAdd,
+      FuncSubtract,
+      FuncReverseSubtract,
+      Min,
+      Max
+    } tag;
+};
+namespace data { 
+}
+class BlendingFactor {
+  public:
+    enum class tag { 
+      Zero,
+      One,
+      SrcColor,
+      OneMinusSrcColor,
+      DstColor,
+      OneMinusDstColor,
+      SrcAlpha,
+      OneMinusSrcAlpha,
+      DstAlpha,
+      OneMinusDstAlpha,
+      ConstantColor,
+      OneMinusConstantColor,
+      ConstantAlpha,
+      OneMinusConstantAlpha,
+      SrcAlphaSaturate
+    } tag;
+};
+namespace data { 
+}
+class LogicOperation {
+  public:
+    enum class tag { 
+      Clear,
+      And,
+      AndReverse,
+      Copy,
+      AndInverted,
+      Noop,
+      Xor,
+      Or,
+      Nor,
+      Equiv,
+      Invert,
+      OrReverse,
+      CopyInverted,
+      OrInverted,
+      Nand,
+      Set
+    } tag;
+};
+namespace data { 
+}
+class StencilOps {
+  public:
+    enum class tag { 
+      StencilOps
+    } tag;
+};
+namespace data { 
+  class StencilOps : public ::StencilOps {
+    public:
+      std::shared_ptr<::StencilOperation> frontStencilOp;
+      std::shared_ptr<::StencilOperation> backStencilOp;
+      StencilOps() { tag = tag::StencilOps; }
+  };
+}
+class StencilTest {
+  public:
+    enum class tag { 
+      StencilTest
+    } tag;
+};
+namespace data { 
+  class StencilTest : public ::StencilTest {
+    public:
+      std::shared_ptr<::ComparisonFunction> stencilComparision;
+      Int32 stencilReference;
+      Word32 stencilMask;
+      StencilTest() { tag = tag::StencilTest; }
+  };
+}
+class StencilTests {
+  public:
+    enum class tag { 
+      StencilTests
+    } tag;
+};
+namespace data { 
+  class StencilTests : public ::StencilTests {
+    public:
+      std::shared_ptr<::StencilTest> _0;
+      std::shared_ptr<::StencilTest> _1;
+      StencilTests() { tag = tag::StencilTests; }
+  };
+}
+class FetchPrimitive {
+  public:
+    enum class tag { 
+      Points,
+      Lines,
+      Triangles,
+      LinesAdjacency,
+      TrianglesAdjacency
+    } tag;
+};
+namespace data { 
+}
+class OutputPrimitive {
+  public:
+    enum class tag { 
+      TrianglesOutput,
+      LinesOutput,
+      PointsOutput
+    } tag;
+};
+namespace data { 
+}
+class ColorArity {
+  public:
+    enum class tag { 
+      Red,
+      RG,
+      RGB,
+      RGBA
+    } tag;
+};
+namespace data { 
+}
+class Blending {
+  public:
+    enum class tag { 
+      NoBlending,
+      BlendLogicOp,
+      Blend
+    } tag;
+};
+namespace data { 
+  class BlendLogicOp : public ::Blending {
+    public:
+      std::shared_ptr<::LogicOperation> _0;
+      BlendLogicOp() { tag = tag::BlendLogicOp; }
+  };
+  class Blend : public ::Blending {
+    public:
+      std::shared_ptr<::BlendEquation> colorEqSrc;
+      std::shared_ptr<::BlendEquation> alphaEqSrc;
+      std::shared_ptr<::BlendingFactor> colorFSrc;
+      std::shared_ptr<::BlendingFactor> colorFDst;
+      std::shared_ptr<::BlendingFactor> alphaFSrc;
+      std::shared_ptr<::BlendingFactor> alphaFDst;
+      V4F color;
+      Blend() { tag = tag::Blend; }
+  };
+}
+class RasterContext {
+  public:
+    enum class tag { 
+      PointCtx,
+      LineCtx,
+      TriangleCtx
+    } tag;
+};
+namespace data { 
+  class PointCtx : public ::RasterContext {
+    public:
+      std::shared_ptr<::PointSize> _0;
+      Float _1;
+      std::shared_ptr<::PointSpriteCoordOrigin> _2;
+      PointCtx() { tag = tag::PointCtx; }
+  };
+  class LineCtx : public ::RasterContext {
+    public:
+      Float _0;
+      std::shared_ptr<::ProvokingVertex> _1;
+      LineCtx() { tag = tag::LineCtx; }
+  };
+  class TriangleCtx : public ::RasterContext {
+    public:
+      std::shared_ptr<::CullMode> _0;
+      std::shared_ptr<::PolygonMode> _1;
+      std::shared_ptr<::PolygonOffset> _2;
+      std::shared_ptr<::ProvokingVertex> _3;
+      TriangleCtx() { tag = tag::TriangleCtx; }
+  };
+}
+class FragmentOperation {
+  public:
+    enum class tag { 
+      DepthOp,
+      StencilOp,
+      ColorOp
+    } tag;
+};
+namespace data { 
+  class DepthOp : public ::FragmentOperation {
+    public:
+      std::shared_ptr<::DepthFunction> _0;
+      Bool _1;
+      DepthOp() { tag = tag::DepthOp; }
+  };
+  class StencilOp : public ::FragmentOperation {
+    public:
+      std::shared_ptr<::StencilTests> _0;
+      std::shared_ptr<::StencilOps> _1;
+      std::shared_ptr<::StencilOps> _2;
+      StencilOp() { tag = tag::StencilOp; }
+  };
+  class ColorOp : public ::FragmentOperation {
+    public:
+      std::shared_ptr<::Blending> _0;
+      std::shared_ptr<::Value> _1;
+      ColorOp() { tag = tag::ColorOp; }
+  };
+}
+class AccumulationContext {
+  public:
+    enum class tag { 
+      AccumulationContext
+    } tag;
+};
+namespace data { 
+  class AccumulationContext : public ::AccumulationContext {
+    public:
+      Maybe<String> accViewportName;
+      std::vector<std::shared_ptr<::FragmentOperation>> accOperations;
+      AccumulationContext() { tag = tag::AccumulationContext; }
+  };
+}
+class TextureDataType {
+  public:
+    enum class tag { 
+      FloatT,
+      IntT,
+      WordT,
+      ShadowT
+    } tag;
+};
+namespace data { 
+  class FloatT : public ::TextureDataType {
+    public:
+      std::shared_ptr<::ColorArity> _0;
+      FloatT() { tag = tag::FloatT; }
+  };
+  class IntT : public ::TextureDataType {
+    public:
+      std::shared_ptr<::ColorArity> _0;
+      IntT() { tag = tag::IntT; }
+  };
+  class WordT : public ::TextureDataType {
+    public:
+      std::shared_ptr<::ColorArity> _0;
+      WordT() { tag = tag::WordT; }
+  };
+}
+class TextureType {
+  public:
+    enum class tag { 
+      Texture1D,
+      Texture2D,
+      Texture3D,
+      TextureCube,
+      TextureRect,
+      Texture2DMS,
+      TextureBuffer
+    } tag;
+};
+namespace data { 
+  class Texture1D : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Int _1;
+      Texture1D() { tag = tag::Texture1D; }
+  };
+  class Texture2D : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Int _1;
+      Texture2D() { tag = tag::Texture2D; }
+  };
+  class Texture3D : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Texture3D() { tag = tag::Texture3D; }
+  };
+  class TextureCube : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      TextureCube() { tag = tag::TextureCube; }
+  };
+  class TextureRect : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      TextureRect() { tag = tag::TextureRect; }
+  };
+  class Texture2DMS : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      Int _1;
+      Int _2;
+      Bool _3;
+      Texture2DMS() { tag = tag::Texture2DMS; }
+  };
+  class TextureBuffer : public ::TextureType {
+    public:
+      std::shared_ptr<::TextureDataType> _0;
+      TextureBuffer() { tag = tag::TextureBuffer; }
+  };
+}
+class MipMap {
+  public:
+    enum class tag { 
+      Mip,
+      NoMip,
+      AutoMip
+    } tag;
+};
+namespace data { 
+  class Mip : public ::MipMap {
+    public:
+      Int _0;
+      Int _1;
+      Mip() { tag = tag::Mip; }
+  };
+  class AutoMip : public ::MipMap {
+    public:
+      Int _0;
+      Int _1;
+      AutoMip() { tag = tag::AutoMip; }
+  };
+}
+class Filter {
+  public:
+    enum class tag { 
+      Nearest,
+      Linear,
+      NearestMipmapNearest,
+      NearestMipmapLinear,
+      LinearMipmapNearest,
+      LinearMipmapLinear
+    } tag;
+};
+namespace data { 
+}
+class EdgeMode {
+  public:
+    enum class tag { 
+      Repeat,
+      MirroredRepeat,
+      ClampToEdge,
+      ClampToBorder
+    } tag;
+};
+namespace data { 
+}
+class ImageSemantic {
+  public:
+    enum class tag { 
+      Depth,
+      Stencil,
+      Color
+    } tag;
+};
+namespace data { 
+}
+class ImageRef {
+  public:
+    enum class tag { 
+      TextureImage,
+      Framebuffer
+    } tag;
+};
+namespace data { 
+  class TextureImage : public ::ImageRef {
+    public:
+      ::TextureName _0;
+      Int _1;
+      Maybe<Int> _2;
+      TextureImage() { tag = tag::TextureImage; }
+  };
+  class Framebuffer : public ::ImageRef {
+    public:
+      std::shared_ptr<::ImageSemantic> _0;
+      Framebuffer() { tag = tag::Framebuffer; }
+  };
+}
+class ClearImage {
+  public:
+    enum class tag { 
+      ClearImage
+    } tag;
+};
+namespace data { 
+  class ClearImage : public ::ClearImage {
+    public:
+      std::shared_ptr<::ImageSemantic> imageSemantic;
+      std::shared_ptr<::Value> clearValue;
+      ClearImage() { tag = tag::ClearImage; }
+  };
+}
+class Command {
+  public:
+    enum class tag { 
+      SetRasterContext,
+      SetAccumulationContext,
+      SetRenderTarget,
+      SetProgram,
+      SetSamplerUniform,
+      SetTexture,
+      SetSampler,
+      RenderSlot,
+      RenderStream,
+      ClearRenderTarget,
+      GenerateMipMap,
+      SaveImage,
+      LoadImage
+    } tag;
+};
+namespace data { 
+  class SetRasterContext : public ::Command {
+    public:
+      std::shared_ptr<::RasterContext> _0;
+      SetRasterContext() { tag = tag::SetRasterContext; }
+  };
+  class SetAccumulationContext : public ::Command {
+    public:
+      std::shared_ptr<::AccumulationContext> _0;
+      SetAccumulationContext() { tag = tag::SetAccumulationContext; }
+  };
+  class SetRenderTarget : public ::Command {
+    public:
+      ::RenderTargetName _0;
+      SetRenderTarget() { tag = tag::SetRenderTarget; }
+  };
+  class SetProgram : public ::Command {
+    public:
+      ::ProgramName _0;
+      SetProgram() { tag = tag::SetProgram; }
+  };
+  class SetSamplerUniform : public ::Command {
+    public:
+      ::UniformName _0;
+      ::TextureUnit _1;
+      SetSamplerUniform() { tag = tag::SetSamplerUniform; }
+  };
+  class SetTexture : public ::Command {
+    public:
+      ::TextureUnit _0;
+      ::TextureName _1;
+      SetTexture() { tag = tag::SetTexture; }
+  };
+  class SetSampler : public ::Command {
+    public:
+      ::TextureUnit _0;
+      Maybe<::SamplerName> _1;
+      SetSampler() { tag = tag::SetSampler; }
+  };
+  class RenderSlot : public ::Command {
+    public:
+      ::SlotName _0;
+      RenderSlot() { tag = tag::RenderSlot; }
+  };
+  class RenderStream : public ::Command {
+    public:
+      ::StreamName _0;
+      RenderStream() { tag = tag::RenderStream; }
+  };
+  class ClearRenderTarget : public ::Command {
+    public:
+      std::vector<std::shared_ptr<::ClearImage>> _0;
+      ClearRenderTarget() { tag = tag::ClearRenderTarget; }
+  };
+  class GenerateMipMap : public ::Command {
+    public:
+      ::TextureUnit _0;
+      GenerateMipMap() { tag = tag::GenerateMipMap; }
+  };
+  class SaveImage : public ::Command {
+    public:
+      ::FrameBufferComponent _0;
+      std::shared_ptr<::ImageRef> _1;
+      SaveImage() { tag = tag::SaveImage; }
+  };
+  class LoadImage : public ::Command {
+    public:
+      std::shared_ptr<::ImageRef> _0;
+      ::FrameBufferComponent _1;
+      LoadImage() { tag = tag::LoadImage; }
+  };
+}
+class SamplerDescriptor {
+  public:
+    enum class tag { 
+      SamplerDescriptor
+    } tag;
+};
+namespace data { 
+  class SamplerDescriptor : public ::SamplerDescriptor {
+    public:
+      std::shared_ptr<::EdgeMode> samplerWrapS;
+      Maybe<std::shared_ptr<::EdgeMode>> samplerWrapT;
+      Maybe<std::shared_ptr<::EdgeMode>> samplerWrapR;
+      std::shared_ptr<::Filter> samplerMinFilter;
+      std::shared_ptr<::Filter> samplerMagFilter;
+      std::shared_ptr<::Value> samplerBorderColor;
+      Maybe<Float> samplerMinLod;
+      Maybe<Float> samplerMaxLod;
+      Float samplerLodBias;
+      Maybe<std::shared_ptr<::ComparisonFunction>> samplerCompareFunc;
+      SamplerDescriptor() { tag = tag::SamplerDescriptor; }
+  };
+}
+class TextureDescriptor {
+  public:
+    enum class tag { 
+      TextureDescriptor
+    } tag;
+};
+namespace data { 
+  class TextureDescriptor : public ::TextureDescriptor {
+    public:
+      std::shared_ptr<::TextureType> textureType;
+      std::shared_ptr<::Value> textureSize;
+      std::shared_ptr<::ImageSemantic> textureSemantic;
+      std::shared_ptr<::SamplerDescriptor> textureSampler;
+      Int textureBaseLevel;
+      Int textureMaxLevel;
+      TextureDescriptor() { tag = tag::TextureDescriptor; }
+  };
+}
+class Parameter {
+  public:
+    enum class tag { 
+      Parameter
+    } tag;
+};
+namespace data { 
+  class Parameter : public ::Parameter {
+    public:
+      String name;
+      std::shared_ptr<::InputType> ty;
+      Parameter() { tag = tag::Parameter; }
+  };
+}
+class Program {
+  public:
+    enum class tag { 
+      Program
+    } tag;
+};
+namespace data { 
+  class Program : public ::Program {
+    public:
+      std::map<::UniformName, std::shared_ptr<::InputType>> programUniforms;
+      std::map<::UniformName, std::shared_ptr<::Parameter>> programStreams;
+      std::map<::UniformName, std::shared_ptr<::InputType>> programInTextures;
+      std::vector<std::shared_ptr<::Parameter>> programOutput;
+      String vertexShader;
+      Maybe<String> geometryShader;
+      String fragmentShader;
+      Program() { tag = tag::Program; }
+  };
+}
+class Slot {
+  public:
+    enum class tag { 
+      Slot
+    } tag;
+};
+namespace data { 
+  class Slot : public ::Slot {
+    public:
+      String slotName;
+      std::map<String, std::shared_ptr<::InputType>> slotStreams;
+      std::map<::UniformName, std::shared_ptr<::InputType>> slotUniforms;
+      std::shared_ptr<::FetchPrimitive> slotPrimitive;
+      std::vector<::ProgramName> slotPrograms;
+      Slot() { tag = tag::Slot; }
+  };
+}
+class StreamData {
+  public:
+    enum class tag { 
+      StreamData
+    } tag;
+};
+namespace data { 
+  class StreamData : public ::StreamData {
+    public:
+      std::map<String, std::shared_ptr<::ArrayValue>> streamData;
+      std::map<String, std::shared_ptr<::InputType>> streamType;
+      std::shared_ptr<::FetchPrimitive> streamPrimitive;
+      std::vector<::ProgramName> streamPrograms;
+      StreamData() { tag = tag::StreamData; }
+  };
+}
+class TargetItem {
+  public:
+    enum class tag { 
+      TargetItem
+    } tag;
+};
+namespace data { 
+  class TargetItem : public ::TargetItem {
+    public:
+      std::shared_ptr<::ImageSemantic> targetSemantic;
+      Maybe<std::shared_ptr<::ImageRef>> targetRef;
+      TargetItem() { tag = tag::TargetItem; }
+  };
+}
+class RenderTarget {
+  public:
+    enum class tag { 
+      RenderTarget
+    } tag;
+};
+namespace data { 
+  class RenderTarget : public ::RenderTarget {
+    public:
+      std::vector<std::shared_ptr<::TargetItem>> renderTargets;
+      RenderTarget() { tag = tag::RenderTarget; }
+  };
+}
+class Backend {
+  public:
+    enum class tag { 
+      WebGL1,
+      OpenGL33
+    } tag;
+};
+namespace data { 
+}
+class Pipeline {
+  public:
+    enum class tag { 
+      Pipeline
+    } tag;
+};
+namespace data { 
+  class Pipeline : public ::Pipeline {
+    public:
+      std::shared_ptr<::Backend> backend;
+      std::vector<std::shared_ptr<::TextureDescriptor>> textures;
+      std::vector<std::shared_ptr<::SamplerDescriptor>> samplers;
+      std::vector<std::shared_ptr<::RenderTarget>> targets;
+      std::vector<std::shared_ptr<::Program>> programs;
+      std::vector<std::shared_ptr<::Slot>> slots;
+      std::vector<std::shared_ptr<::StreamData>> streams;
+      std::vector<std::shared_ptr<::Command>> commands;
+      Pipeline() { tag = tag::Pipeline; }
+  };
+}
+#endif