From c5e063b3c9aeff65161e24445e9672daff980b45 Mon Sep 17 00:00:00 2001 From: Csaba Hruska Date: Sun, 20 Mar 2016 22:44:29 +0100 Subject: working c# backend --- ddl/Generate.hs | 28 +- ddl/Language.hs | 83 +- ddl/out/LambdaCube.IR.cpp | 4 + ddl/out/LambdaCube.IR.cs | 4444 ++++++++++++++++++++ ddl/out/LambdaCube.IR.hpp | 4 + ddl/out/LambdaCube.IR.hs | 4 + ddl/out/LambdaCube.IR.java | 877 ++++ ddl/out/LambdaCube.IR.purs | 4 + ddl/out/LambdaCube.IR.swift | 4 + ddl/out/LambdaCube.IR2.hpp | 4 + ddl/out/LambdaCube.Mesh.cpp | 4 + ddl/out/LambdaCube.Mesh.cs | 529 +++ ddl/out/LambdaCube.Mesh.hpp | 4 + ddl/out/LambdaCube.Mesh.hs | 4 + ddl/out/LambdaCube.Mesh.java | 79 + ddl/out/LambdaCube.Mesh.purs | 4 + ddl/out/LambdaCube.Mesh.swift | 4 + ddl/out/LambdaCube.Mesh2.hpp | 4 + ddl/out/LambdaCube.PipelineSchema.cpp | 4 + ddl/out/LambdaCube.PipelineSchema.cs | 339 ++ ddl/out/LambdaCube.PipelineSchema.hpp | 4 + ddl/out/LambdaCube.PipelineSchema.hs | 4 + ddl/out/LambdaCube.PipelineSchema.java | 59 + ddl/out/LambdaCube.PipelineSchema.purs | 4 + ddl/out/LambdaCube.PipelineSchema.swift | 4 + ddl/out/LambdaCube.PipelineSchema2.hpp | 4 + ddl/out/LambdaCube.TypeInfo.cpp | 4 + ddl/out/LambdaCube.TypeInfo.cs | 218 + ddl/out/LambdaCube.TypeInfo.hpp | 4 + ddl/out/LambdaCube.TypeInfo.hs | 4 + ddl/out/LambdaCube.TypeInfo.java | 52 + ddl/out/LambdaCube.TypeInfo.purs | 4 + ddl/out/LambdaCube.TypeInfo.swift | 4 + ddl/out/LambdaCube.TypeInfo2.hpp | 4 + ddl/out/TestData.cpp | 4 + ddl/out/TestData.cs | 499 +++ ddl/out/TestData.hpp | 4 + ddl/out/TestData.hs | 4 + ddl/out/TestData.java | 103 + ddl/out/TestData.purs | 4 + ddl/out/TestData.swift | 4 + ddl/out/TestData2.hpp | 4 + .../java/LambdaCube/IR/AccumulationContext.java | 23 + ddl/out/java/LambdaCube/IR/ArrayValue.java | 37 + ddl/out/java/LambdaCube/IR/Backend.java | 19 + ddl/out/java/LambdaCube/IR/BlendEquation.java | 22 + ddl/out/java/LambdaCube/IR/Blending.java | 34 + ddl/out/java/LambdaCube/IR/BlendingFactor.java | 32 + ddl/out/java/LambdaCube/IR/ClearImage.java | 23 + ddl/out/java/LambdaCube/IR/ColorArity.java | 21 + ddl/out/java/LambdaCube/IR/Command.java | 87 + ddl/out/java/LambdaCube/IR/ComparisonFunction.java | 25 + ddl/out/java/LambdaCube/IR/CullMode.java | 28 + ddl/out/java/LambdaCube/IR/EdgeMode.java | 21 + ddl/out/java/LambdaCube/IR/FetchPrimitive.java | 22 + ddl/out/java/LambdaCube/IR/Filter.java | 23 + ddl/out/java/LambdaCube/IR/FragmentOperation.java | 36 + ddl/out/java/LambdaCube/IR/FrontFace.java | 19 + ddl/out/java/LambdaCube/IR/ImageRef.java | 29 + ddl/out/java/LambdaCube/IR/ImageSemantic.java | 20 + ddl/out/java/LambdaCube/IR/InputType.java | 78 + ddl/out/java/LambdaCube/IR/JSON.java | 1460 +++++++ ddl/out/java/LambdaCube/IR/LogicOperation.java | 33 + ddl/out/java/LambdaCube/IR/MipMap.java | 30 + ddl/out/java/LambdaCube/IR/OutputPrimitive.java | 20 + ddl/out/java/LambdaCube/IR/Parameter.java | 23 + ddl/out/java/LambdaCube/IR/Pipeline.java | 30 + ddl/out/java/LambdaCube/IR/PointSize.java | 23 + .../java/LambdaCube/IR/PointSpriteCoordOrigin.java | 19 + ddl/out/java/LambdaCube/IR/PolygonMode.java | 28 + ddl/out/java/LambdaCube/IR/PolygonOffset.java | 24 + ddl/out/java/LambdaCube/IR/Program.java | 28 + ddl/out/java/LambdaCube/IR/ProvokingVertex.java | 19 + ddl/out/java/LambdaCube/IR/RasterContext.java | 38 + ddl/out/java/LambdaCube/IR/RenderTarget.java | 22 + ddl/out/java/LambdaCube/IR/SamplerDescriptor.java | 31 + ddl/out/java/LambdaCube/IR/Slot.java | 26 + ddl/out/java/LambdaCube/IR/StencilOperation.java | 25 + ddl/out/java/LambdaCube/IR/StencilOps.java | 23 + ddl/out/java/LambdaCube/IR/StencilTest.java | 24 + ddl/out/java/LambdaCube/IR/StencilTests.java | 23 + ddl/out/java/LambdaCube/IR/StreamData.java | 25 + ddl/out/java/LambdaCube/IR/TargetItem.java | 23 + ddl/out/java/LambdaCube/IR/TextureDataType.java | 33 + ddl/out/java/LambdaCube/IR/TextureDescriptor.java | 27 + ddl/out/java/LambdaCube/IR/TextureType.java | 57 + ddl/out/java/LambdaCube/IR/Value.java | 142 + ddl/out/java/LambdaCube/Mesh/JSON.java | 206 + ddl/out/java/LambdaCube/Mesh/Mesh.java | 23 + ddl/out/java/LambdaCube/Mesh/MeshAttribute.java | 62 + ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java | 30 + ddl/out/java/LambdaCube/PipelineSchema/JSON.java | 122 + .../PipelineSchema/ObjectArraySchema.java | 24 + .../LambdaCube/PipelineSchema/PipelineSchema.java | 24 + .../java/LambdaCube/PipelineSchema/StreamType.java | 39 + .../java/LambdaCube/TypeInfo/CompileResult.java | 32 + ddl/out/java/LambdaCube/TypeInfo/JSON.java | 85 + ddl/out/java/LambdaCube/TypeInfo/Range.java | 26 + ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java | 24 + ddl/out/java/TestData/ClientInfo.java | 26 + ddl/out/java/TestData/Frame.java | 27 + ddl/out/java/TestData/FrameResult.java | 27 + ddl/out/java/TestData/JSON.java | 193 + ddl/out/java/TestData/PipelineInfo.java | 26 + ddl/out/java/TestData/RenderJob.java | 29 + ddl/out/java/TestData/RenderJobResult.java | 30 + ddl/out/java/TestData/Scene.java | 28 + ddl/templates/data.cs.ede | 208 +- ddl/templates/data.hpp.ede | 2 +- ddl/templates/data.hpp2.ede | 2 +- ddl/templates/data.java.ede | 33 +- 111 files changed, 11549 insertions(+), 64 deletions(-) create mode 100644 ddl/out/LambdaCube.IR.cs create mode 100644 ddl/out/LambdaCube.IR.java create mode 100644 ddl/out/LambdaCube.Mesh.cs create mode 100644 ddl/out/LambdaCube.Mesh.java create mode 100644 ddl/out/LambdaCube.PipelineSchema.cs create mode 100644 ddl/out/LambdaCube.PipelineSchema.java create mode 100644 ddl/out/LambdaCube.TypeInfo.cs create mode 100644 ddl/out/LambdaCube.TypeInfo.java create mode 100644 ddl/out/TestData.cs create mode 100644 ddl/out/TestData.java create mode 100644 ddl/out/java/LambdaCube/IR/AccumulationContext.java create mode 100644 ddl/out/java/LambdaCube/IR/ArrayValue.java create mode 100644 ddl/out/java/LambdaCube/IR/Backend.java create mode 100644 ddl/out/java/LambdaCube/IR/BlendEquation.java create mode 100644 ddl/out/java/LambdaCube/IR/Blending.java create mode 100644 ddl/out/java/LambdaCube/IR/BlendingFactor.java create mode 100644 ddl/out/java/LambdaCube/IR/ClearImage.java create mode 100644 ddl/out/java/LambdaCube/IR/ColorArity.java create mode 100644 ddl/out/java/LambdaCube/IR/Command.java create mode 100644 ddl/out/java/LambdaCube/IR/ComparisonFunction.java create mode 100644 ddl/out/java/LambdaCube/IR/CullMode.java create mode 100644 ddl/out/java/LambdaCube/IR/EdgeMode.java create mode 100644 ddl/out/java/LambdaCube/IR/FetchPrimitive.java create mode 100644 ddl/out/java/LambdaCube/IR/Filter.java create mode 100644 ddl/out/java/LambdaCube/IR/FragmentOperation.java create mode 100644 ddl/out/java/LambdaCube/IR/FrontFace.java create mode 100644 ddl/out/java/LambdaCube/IR/ImageRef.java create mode 100644 ddl/out/java/LambdaCube/IR/ImageSemantic.java create mode 100644 ddl/out/java/LambdaCube/IR/InputType.java create mode 100644 ddl/out/java/LambdaCube/IR/JSON.java create mode 100644 ddl/out/java/LambdaCube/IR/LogicOperation.java create mode 100644 ddl/out/java/LambdaCube/IR/MipMap.java create mode 100644 ddl/out/java/LambdaCube/IR/OutputPrimitive.java create mode 100644 ddl/out/java/LambdaCube/IR/Parameter.java create mode 100644 ddl/out/java/LambdaCube/IR/Pipeline.java create mode 100644 ddl/out/java/LambdaCube/IR/PointSize.java create mode 100644 ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java create mode 100644 ddl/out/java/LambdaCube/IR/PolygonMode.java create mode 100644 ddl/out/java/LambdaCube/IR/PolygonOffset.java create mode 100644 ddl/out/java/LambdaCube/IR/Program.java create mode 100644 ddl/out/java/LambdaCube/IR/ProvokingVertex.java create mode 100644 ddl/out/java/LambdaCube/IR/RasterContext.java create mode 100644 ddl/out/java/LambdaCube/IR/RenderTarget.java create mode 100644 ddl/out/java/LambdaCube/IR/SamplerDescriptor.java create mode 100644 ddl/out/java/LambdaCube/IR/Slot.java create mode 100644 ddl/out/java/LambdaCube/IR/StencilOperation.java create mode 100644 ddl/out/java/LambdaCube/IR/StencilOps.java create mode 100644 ddl/out/java/LambdaCube/IR/StencilTest.java create mode 100644 ddl/out/java/LambdaCube/IR/StencilTests.java create mode 100644 ddl/out/java/LambdaCube/IR/StreamData.java create mode 100644 ddl/out/java/LambdaCube/IR/TargetItem.java create mode 100644 ddl/out/java/LambdaCube/IR/TextureDataType.java create mode 100644 ddl/out/java/LambdaCube/IR/TextureDescriptor.java create mode 100644 ddl/out/java/LambdaCube/IR/TextureType.java create mode 100644 ddl/out/java/LambdaCube/IR/Value.java create mode 100644 ddl/out/java/LambdaCube/Mesh/JSON.java create mode 100644 ddl/out/java/LambdaCube/Mesh/Mesh.java create mode 100644 ddl/out/java/LambdaCube/Mesh/MeshAttribute.java create mode 100644 ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java create mode 100644 ddl/out/java/LambdaCube/PipelineSchema/JSON.java create mode 100644 ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java create mode 100644 ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java create mode 100644 ddl/out/java/LambdaCube/PipelineSchema/StreamType.java create mode 100644 ddl/out/java/LambdaCube/TypeInfo/CompileResult.java create mode 100644 ddl/out/java/LambdaCube/TypeInfo/JSON.java create mode 100644 ddl/out/java/LambdaCube/TypeInfo/Range.java create mode 100644 ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java create mode 100644 ddl/out/java/TestData/ClientInfo.java create mode 100644 ddl/out/java/TestData/Frame.java create mode 100644 ddl/out/java/TestData/FrameResult.java create mode 100644 ddl/out/java/TestData/JSON.java create mode 100644 ddl/out/java/TestData/PipelineInfo.java create mode 100644 ddl/out/java/TestData/RenderJob.java create mode 100644 ddl/out/java/TestData/RenderJobResult.java create mode 100644 ddl/out/java/TestData/Scene.java diff --git a/ddl/Generate.hs b/ddl/Generate.hs index 532a012..9f9b7b8 100644 --- a/ddl/Generate.hs +++ b/ddl/Generate.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE OverloadedStrings, FlexibleInstances #-} +{-# LANGUAGE OverloadedStrings, FlexibleInstances, LambdaCase #-} import qualified Data.Text.Lazy as LText import Text.EDE import Text.EDE.Filters @@ -7,8 +7,10 @@ import Data.HashMap.Strict (HashMap) import qualified Data.HashMap.Strict as HashMap import Data.Text (Text) import qualified Data.Map as Map +import qualified Data.Set as Set import System.Directory +import System.FilePath import Data.Time.Clock import Control.Monad.Writer @@ -32,7 +34,7 @@ main = do dataCs <- eitherParseFile "templates/data.cs.ede" dataHs <- eitherParseFile "templates/data.hs.ede" dataPs <- eitherParseFile "templates/data.purs.ede" - let generate (ModuleDef name imports def) = do + let generate mod@(ModuleDef name imports def) = do dt <- getCurrentTime let env = fromPairs [ "dataAndType" .= def @@ -40,6 +42,8 @@ main = do , "moduleName" .= name , "dateTime" .= dt , "imports" .= imports + , "usedTypes" .= collectTypes aliasMap mod + , "usedCSTypes" .= (Set.fromList $ Map.elems $ Map.fromList [ (csType name aliasMap t,t) | t <- Set.toList $ collectTypes aliasMap mod]) ] aliasMap = Map.fromList [(n,t) | TypeAlias n t <- def] mylib :: HashMap Text Term @@ -50,7 +54,8 @@ main = do , "hsType" @: hsType aliasMap , "psType" @: psType aliasMap , "cppType" @: cppType aliasMap - , "csType" @: csType aliasMap + , "csType" @: csType name aliasMap + , "csTypeEnum" @: csTypeEnum aliasMap , "javaType" @: javaType aliasMap , "swiftType" @: swiftType aliasMap ] @@ -63,12 +68,23 @@ main = do either error (\x -> writeFile ("out/" ++ name ++ "2.hpp") $ LText.unpack x) $ dataHpp2 >>= (\t -> eitherRenderWith mylib t env) either error (\x -> writeFile ("out/" ++ name ++ ".hpp") $ LText.unpack x) $ dataHpp >>= (\t -> eitherRenderWith mylib t env) either error (\x -> writeFile ("out/" ++ name ++ ".cpp") $ LText.unpack x) $ dataCpp >>= (\t -> eitherRenderWith mylib t env) - {- -- Java - either error (\x -> writeFile ("out/" ++ name ++ ".java") $ LText.unpack x) $ dataJava >>= (\t -> eitherRenderWith mylib t env) + forM_ [a | a@DataDef{} <- def {-TODO-}] $ \d -> do + let env = fromPairs + [ "def" .= d + , "moduleName" .= name + , "dateTime" .= dt + , "imports" .= imports + ] + toPath a = flip map a $ \case + '.' -> '/' + c -> c + fname = "out/java/" ++ toPath name ++ "/" ++ dataName d ++ ".java" + dir = takeDirectory fname + createDirectoryIfMissing True dir + either error (\x -> writeFile fname $ LText.unpack x) $ dataJava >>= (\t -> eitherRenderWith mylib t env) -- C# either error (\x -> writeFile ("out/" ++ name ++ ".cs") $ LText.unpack x) $ dataCs >>= (\t -> eitherRenderWith mylib t env) - -} -- Swift either error (\x -> writeFile ("out/" ++ name ++ ".swift") $ LText.unpack x) $ dataSwift >>= (\t -> eitherRenderWith mylib t env) mapM_ generate $ execWriter modules diff --git a/ddl/Language.hs b/ddl/Language.hs index 79c3056..989314a 100644 --- a/ddl/Language.hs +++ b/ddl/Language.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE RankNTypes, OverloadedStrings, DeriveGeneric, LambdaCase #-} +{-# LANGUAGE RankNTypes, OverloadedStrings, DeriveGeneric, LambdaCase, RecordWildCards #-} module Language where import GHC.Generics @@ -8,6 +8,8 @@ import Data.String import Data.List import Data.Map (Map) import qualified Data.Map as Map +import Data.Set (Set) +import qualified Data.Set as Set instance IsString Type where fromString a = Data a @@ -67,17 +69,21 @@ data Type | Float | Bool | String - | V2 Type - | V3 Type - | V4 Type -- higher order types - | Array Type - | List Type - | Maybe Type - | Map Type Type + | V2 { type_ :: Type } + | V3 { type_ :: Type } + | V4 { type_ :: Type } + | Array { type_ :: Type } + | List { type_ :: Type } + | Maybe { type_ :: Type } + | Map { key_ :: Type, value_ :: Type } -- user defined - | Data String - deriving (Show,Generic) + | Data { name_ :: String } + deriving (Show,Generic,Eq,Ord) + +collectTypes :: AliasMap -> ModuleDef -> Set Type +collectTypes aliasMap ModuleDef{..} = Set.fromList $ map (normalize aliasMap) $ concat + [Data dataName : [fieldType | ConstructorDef{..} <- constructors, Field{..} <- fields] | DataDef{..} <- definitions] parens :: String -> String parens a @@ -88,6 +94,13 @@ type AliasMap = Map String Type normalize :: AliasMap -> Type -> Type normalize aliasMap t@(Data n) = Map.findWithDefault t n aliasMap +normalize aliasMap (V2 t) = V2 $ normalize aliasMap t +normalize aliasMap (V3 t) = V3 $ normalize aliasMap t +normalize aliasMap (V4 t) = V4 $ normalize aliasMap t +normalize aliasMap (Array t) = Array $ normalize aliasMap t +normalize aliasMap (List t) = List $ normalize aliasMap t +normalize aliasMap (Maybe t) = Maybe $ normalize aliasMap t +normalize aliasMap (Map k v) = Map (normalize aliasMap k) (normalize aliasMap v) normalize _ t = t psType :: AliasMap -> Type -> String @@ -222,21 +235,41 @@ swiftType aliasMap = \case javaType :: AliasMap -> Type -> String -- TODO javaType aliasMap a = case normalize aliasMap a of Data t -> t - Int -> "int" - Int32 -> "int" - Word -> "int" - Word32 -> "int" - Float -> "float" - Bool -> "boolean" + Int -> "Integer" + Int32 -> "Integer" + Word -> "Integer" + Word32 -> "Integer" + Float -> "Float" + Bool -> "Boolean" String -> "String" Array t -> "ArrayList<" ++ javaType aliasMap t ++ ">" List t -> "ArrayList<" ++ javaType aliasMap t ++ ">" Map k v -> "HashMap<" ++ javaType aliasMap k ++ ", " ++ javaType aliasMap v ++ ">" - _ -> "int" + _ -> "Integer" + --x -> error $ "javaType: " ++ show x -csType :: AliasMap -> Type -> String -- TODO -csType aliasMap a = case normalize aliasMap a of +csTypeEnum :: AliasMap -> Type -> String +csTypeEnum aliasMap a = case normalize aliasMap a of Data t -> t + Int -> "Int" + Int32 -> "Int32" + Word -> "Word" + Word32 -> "Word32" + Float -> "Float" + Bool -> "Bool" + String -> "String" + Array t -> "Array_" ++ csTypeEnum aliasMap t + List t -> "List_" ++ csTypeEnum aliasMap t + Map k v -> "Map_" ++ csTypeEnum aliasMap k ++ "_" ++ csTypeEnum aliasMap v + V2 t -> "V2_" ++ csTypeEnum aliasMap t + V3 t -> "V3_" ++ csTypeEnum aliasMap t + V4 t -> "V4_" ++ csTypeEnum aliasMap t + Maybe t -> "Maybe_" ++ csTypeEnum aliasMap t + x -> error $ "unknown type: " ++ show x + +csType :: String -> AliasMap -> Type -> String -- TODO +csType moduleName aliasMap a = case normalize aliasMap a of + Data t -> "global::" ++ moduleName ++ "." ++ t Int -> "int" Int32 -> "int" Word -> "uint" @@ -244,10 +277,14 @@ csType aliasMap a = case normalize aliasMap a of Float -> "float" Bool -> "bool" String -> "string" - Array t -> "List<" ++ csType aliasMap t ++ ">" - List t -> "List<" ++ csType aliasMap t ++ ">" - Map k v -> "Dictionary<" ++ csType aliasMap k ++ ", " ++ csType aliasMap v ++ ">" - _ -> "int" + Array t -> "List<" ++ csType moduleName aliasMap t ++ ">" + List t -> "List<" ++ csType moduleName aliasMap t ++ ">" + Map k v -> "Dictionary<" ++ csType moduleName aliasMap k ++ ", " ++ csType moduleName aliasMap v ++ ">" + V2 t -> "V2<" ++ csType moduleName aliasMap t ++ ">" + V3 t -> "V3<" ++ csType moduleName aliasMap t ++ ">" + V4 t -> "V4<" ++ csType moduleName aliasMap t ++ ">" + Maybe t -> "Maybe<" ++ parens (csType moduleName aliasMap t) ++ ">" + x -> error $ "unknown type: " ++ show x cppType :: AliasMap -> Type -> String cppType aliasMap = \case diff --git a/ddl/out/LambdaCube.IR.cpp b/ddl/out/LambdaCube.IR.cpp index 75a26eb..fcbcebb 100644 --- a/ddl/out/LambdaCube.IR.cpp +++ b/ddl/out/LambdaCube.IR.cpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.426854000000Z +======= +// 2016-03-20T21:42:12.172652000000Z +>>>>>>> working c# backend #include "LambdaCube.IR.hpp" template<> json toJSON>(std::shared_ptr &v) { diff --git a/ddl/out/LambdaCube.IR.cs b/ddl/out/LambdaCube.IR.cs new file mode 100644 index 0000000..3c603ca --- /dev/null +++ b/ddl/out/LambdaCube.IR.cs @@ -0,0 +1,4444 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +using System; +using System.Linq; +using System.Collections.Generic; +using Newtonsoft.Json.Linq; + + +namespace LambdaCube.IR { + class ArrayValue { + public enum Tag { + VBoolArray, + VIntArray, + VWordArray, + VFloatArray + }; + public Tag tag; + }; + + namespace data { + class VBoolArray : LambdaCube.IR.ArrayValue { + public List _0; + public VBoolArray() { tag = LambdaCube.IR.ArrayValue.Tag.VBoolArray; } + }; + class VIntArray : LambdaCube.IR.ArrayValue { + public List _0; + public VIntArray() { tag = LambdaCube.IR.ArrayValue.Tag.VIntArray; } + }; + class VWordArray : LambdaCube.IR.ArrayValue { + public List _0; + public VWordArray() { tag = LambdaCube.IR.ArrayValue.Tag.VWordArray; } + }; + class VFloatArray : LambdaCube.IR.ArrayValue { + public List _0; + public VFloatArray() { tag = LambdaCube.IR.ArrayValue.Tag.VFloatArray; } + }; + } + class Value { + public enum 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 + }; + public Tag tag; + }; + + namespace data { + class VBool : LambdaCube.IR.Value { + public bool _0; + public VBool() { tag = LambdaCube.IR.Value.Tag.VBool; } + }; + class VV2B : LambdaCube.IR.Value { + public V2 _0; + public VV2B() { tag = LambdaCube.IR.Value.Tag.VV2B; } + }; + class VV3B : LambdaCube.IR.Value { + public V3 _0; + public VV3B() { tag = LambdaCube.IR.Value.Tag.VV3B; } + }; + class VV4B : LambdaCube.IR.Value { + public V4 _0; + public VV4B() { tag = LambdaCube.IR.Value.Tag.VV4B; } + }; + class VWord : LambdaCube.IR.Value { + public uint _0; + public VWord() { tag = LambdaCube.IR.Value.Tag.VWord; } + }; + class VV2U : LambdaCube.IR.Value { + public V2 _0; + public VV2U() { tag = LambdaCube.IR.Value.Tag.VV2U; } + }; + class VV3U : LambdaCube.IR.Value { + public V3 _0; + public VV3U() { tag = LambdaCube.IR.Value.Tag.VV3U; } + }; + class VV4U : LambdaCube.IR.Value { + public V4 _0; + public VV4U() { tag = LambdaCube.IR.Value.Tag.VV4U; } + }; + class VInt : LambdaCube.IR.Value { + public int _0; + public VInt() { tag = LambdaCube.IR.Value.Tag.VInt; } + }; + class VV2I : LambdaCube.IR.Value { + public V2 _0; + public VV2I() { tag = LambdaCube.IR.Value.Tag.VV2I; } + }; + class VV3I : LambdaCube.IR.Value { + public V3 _0; + public VV3I() { tag = LambdaCube.IR.Value.Tag.VV3I; } + }; + class VV4I : LambdaCube.IR.Value { + public V4 _0; + public VV4I() { tag = LambdaCube.IR.Value.Tag.VV4I; } + }; + class VFloat : LambdaCube.IR.Value { + public float _0; + public VFloat() { tag = LambdaCube.IR.Value.Tag.VFloat; } + }; + class VV2F : LambdaCube.IR.Value { + public V2 _0; + public VV2F() { tag = LambdaCube.IR.Value.Tag.VV2F; } + }; + class VV3F : LambdaCube.IR.Value { + public V3 _0; + public VV3F() { tag = LambdaCube.IR.Value.Tag.VV3F; } + }; + class VV4F : LambdaCube.IR.Value { + public V4 _0; + public VV4F() { tag = LambdaCube.IR.Value.Tag.VV4F; } + }; + class VM22F : LambdaCube.IR.Value { + public V2> _0; + public VM22F() { tag = LambdaCube.IR.Value.Tag.VM22F; } + }; + class VM23F : LambdaCube.IR.Value { + public V3> _0; + public VM23F() { tag = LambdaCube.IR.Value.Tag.VM23F; } + }; + class VM24F : LambdaCube.IR.Value { + public V4> _0; + public VM24F() { tag = LambdaCube.IR.Value.Tag.VM24F; } + }; + class VM32F : LambdaCube.IR.Value { + public V2> _0; + public VM32F() { tag = LambdaCube.IR.Value.Tag.VM32F; } + }; + class VM33F : LambdaCube.IR.Value { + public V3> _0; + public VM33F() { tag = LambdaCube.IR.Value.Tag.VM33F; } + }; + class VM34F : LambdaCube.IR.Value { + public V4> _0; + public VM34F() { tag = LambdaCube.IR.Value.Tag.VM34F; } + }; + class VM42F : LambdaCube.IR.Value { + public V2> _0; + public VM42F() { tag = LambdaCube.IR.Value.Tag.VM42F; } + }; + class VM43F : LambdaCube.IR.Value { + public V3> _0; + public VM43F() { tag = LambdaCube.IR.Value.Tag.VM43F; } + }; + class VM44F : LambdaCube.IR.Value { + public V4> _0; + public VM44F() { tag = LambdaCube.IR.Value.Tag.VM44F; } + }; + } + class InputType { + public enum 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 + }; + public Tag tag; + }; + + namespace data { + } + class PointSpriteCoordOrigin { + public enum Tag { + LowerLeft, + UpperLeft + }; + public Tag tag; + }; + + namespace data { + } + class PointSize { + public enum Tag { + PointSize, + ProgramPointSize + }; + public Tag tag; + }; + + namespace data { + class PointSize : LambdaCube.IR.PointSize { + public float _0; + public PointSize() { tag = LambdaCube.IR.PointSize.Tag.PointSize; } + }; + } + class PolygonOffset { + public enum Tag { + NoOffset, + Offset + }; + public Tag tag; + }; + + namespace data { + class Offset : LambdaCube.IR.PolygonOffset { + public float _0; + public float _1; + public Offset() { tag = LambdaCube.IR.PolygonOffset.Tag.Offset; } + }; + } + class FrontFace { + public enum Tag { + CCW, + CW + }; + public Tag tag; + }; + + namespace data { + } + class PolygonMode { + public enum Tag { + PolygonPoint, + PolygonLine, + PolygonFill + }; + public Tag tag; + }; + + namespace data { + class PolygonPoint : LambdaCube.IR.PolygonMode { + public global::LambdaCube.IR.PointSize _0; + public PolygonPoint() { tag = LambdaCube.IR.PolygonMode.Tag.PolygonPoint; } + }; + class PolygonLine : LambdaCube.IR.PolygonMode { + public float _0; + public PolygonLine() { tag = LambdaCube.IR.PolygonMode.Tag.PolygonLine; } + }; + } + class ProvokingVertex { + public enum Tag { + FirstVertex, + LastVertex + }; + public Tag tag; + }; + + namespace data { + } + class CullMode { + public enum Tag { + CullNone, + CullFront, + CullBack + }; + public Tag tag; + }; + + namespace data { + class CullFront : LambdaCube.IR.CullMode { + public global::LambdaCube.IR.FrontFace _0; + public CullFront() { tag = LambdaCube.IR.CullMode.Tag.CullFront; } + }; + class CullBack : LambdaCube.IR.CullMode { + public global::LambdaCube.IR.FrontFace _0; + public CullBack() { tag = LambdaCube.IR.CullMode.Tag.CullBack; } + }; + } + class ComparisonFunction { + public enum Tag { + Never, + Less, + Equal, + Lequal, + Greater, + Notequal, + Gequal, + Always + }; + public Tag tag; + }; + + namespace data { + } + class StencilOperation { + public enum Tag { + OpZero, + OpKeep, + OpReplace, + OpIncr, + OpIncrWrap, + OpDecr, + OpDecrWrap, + OpInvert + }; + public Tag tag; + }; + + namespace data { + } + class BlendEquation { + public enum Tag { + FuncAdd, + FuncSubtract, + FuncReverseSubtract, + Min, + Max + }; + public Tag tag; + }; + + namespace data { + } + class BlendingFactor { + public enum Tag { + Zero, + One, + SrcColor, + OneMinusSrcColor, + DstColor, + OneMinusDstColor, + SrcAlpha, + OneMinusSrcAlpha, + DstAlpha, + OneMinusDstAlpha, + ConstantColor, + OneMinusConstantColor, + ConstantAlpha, + OneMinusConstantAlpha, + SrcAlphaSaturate + }; + public Tag tag; + }; + + namespace data { + } + class LogicOperation { + public enum Tag { + Clear, + And, + AndReverse, + Copy, + AndInverted, + Noop, + Xor, + Or, + Nor, + Equiv, + Invert, + OrReverse, + CopyInverted, + OrInverted, + Nand, + Set + }; + public Tag tag; + }; + + namespace data { + } + class StencilOps { + public enum Tag { + StencilOps + }; + public Tag tag; + }; + + namespace data { + class StencilOps : LambdaCube.IR.StencilOps { + public global::LambdaCube.IR.StencilOperation frontStencilOp; + public global::LambdaCube.IR.StencilOperation backStencilOp; + public StencilOps() { tag = LambdaCube.IR.StencilOps.Tag.StencilOps; } + }; + } + class StencilTest { + public enum Tag { + StencilTest + }; + public Tag tag; + }; + + namespace data { + class StencilTest : LambdaCube.IR.StencilTest { + public global::LambdaCube.IR.ComparisonFunction stencilComparision; + public int stencilReference; + public uint stencilMask; + public StencilTest() { tag = LambdaCube.IR.StencilTest.Tag.StencilTest; } + }; + } + class StencilTests { + public enum Tag { + StencilTests + }; + public Tag tag; + }; + + namespace data { + class StencilTests : LambdaCube.IR.StencilTests { + public global::LambdaCube.IR.StencilTest _0; + public global::LambdaCube.IR.StencilTest _1; + public StencilTests() { tag = LambdaCube.IR.StencilTests.Tag.StencilTests; } + }; + } + class FetchPrimitive { + public enum Tag { + Points, + Lines, + Triangles, + LinesAdjacency, + TrianglesAdjacency + }; + public Tag tag; + }; + + namespace data { + } + class OutputPrimitive { + public enum Tag { + TrianglesOutput, + LinesOutput, + PointsOutput + }; + public Tag tag; + }; + + namespace data { + } + class ColorArity { + public enum Tag { + Red, + RG, + RGB, + RGBA + }; + public Tag tag; + }; + + namespace data { + } + class Blending { + public enum Tag { + NoBlending, + BlendLogicOp, + Blend + }; + public Tag tag; + }; + + namespace data { + class BlendLogicOp : LambdaCube.IR.Blending { + public global::LambdaCube.IR.LogicOperation _0; + public BlendLogicOp() { tag = LambdaCube.IR.Blending.Tag.BlendLogicOp; } + }; + class Blend : LambdaCube.IR.Blending { + public global::LambdaCube.IR.BlendEquation colorEqSrc; + public global::LambdaCube.IR.BlendEquation alphaEqSrc; + public global::LambdaCube.IR.BlendingFactor colorFSrc; + public global::LambdaCube.IR.BlendingFactor colorFDst; + public global::LambdaCube.IR.BlendingFactor alphaFSrc; + public global::LambdaCube.IR.BlendingFactor alphaFDst; + public V4 color; + public Blend() { tag = LambdaCube.IR.Blending.Tag.Blend; } + }; + } + class RasterContext { + public enum Tag { + PointCtx, + LineCtx, + TriangleCtx + }; + public Tag tag; + }; + + namespace data { + class PointCtx : LambdaCube.IR.RasterContext { + public global::LambdaCube.IR.PointSize _0; + public float _1; + public global::LambdaCube.IR.PointSpriteCoordOrigin _2; + public PointCtx() { tag = LambdaCube.IR.RasterContext.Tag.PointCtx; } + }; + class LineCtx : LambdaCube.IR.RasterContext { + public float _0; + public global::LambdaCube.IR.ProvokingVertex _1; + public LineCtx() { tag = LambdaCube.IR.RasterContext.Tag.LineCtx; } + }; + class TriangleCtx : LambdaCube.IR.RasterContext { + public global::LambdaCube.IR.CullMode _0; + public global::LambdaCube.IR.PolygonMode _1; + public global::LambdaCube.IR.PolygonOffset _2; + public global::LambdaCube.IR.ProvokingVertex _3; + public TriangleCtx() { tag = LambdaCube.IR.RasterContext.Tag.TriangleCtx; } + }; + } + class FragmentOperation { + public enum Tag { + DepthOp, + StencilOp, + ColorOp + }; + public Tag tag; + }; + + namespace data { + class DepthOp : LambdaCube.IR.FragmentOperation { + public global::LambdaCube.IR.ComparisonFunction _0; + public bool _1; + public DepthOp() { tag = LambdaCube.IR.FragmentOperation.Tag.DepthOp; } + }; + class StencilOp : LambdaCube.IR.FragmentOperation { + public global::LambdaCube.IR.StencilTests _0; + public global::LambdaCube.IR.StencilOps _1; + public global::LambdaCube.IR.StencilOps _2; + public StencilOp() { tag = LambdaCube.IR.FragmentOperation.Tag.StencilOp; } + }; + class ColorOp : LambdaCube.IR.FragmentOperation { + public global::LambdaCube.IR.Blending _0; + public global::LambdaCube.IR.Value _1; + public ColorOp() { tag = LambdaCube.IR.FragmentOperation.Tag.ColorOp; } + }; + } + class AccumulationContext { + public enum Tag { + AccumulationContext + }; + public Tag tag; + }; + + namespace data { + class AccumulationContext : LambdaCube.IR.AccumulationContext { + public Maybe accViewportName; + public List accOperations; + public AccumulationContext() { tag = LambdaCube.IR.AccumulationContext.Tag.AccumulationContext; } + }; + } + class TextureDataType { + public enum Tag { + FloatT, + IntT, + WordT, + ShadowT + }; + public Tag tag; + }; + + namespace data { + class FloatT : LambdaCube.IR.TextureDataType { + public global::LambdaCube.IR.ColorArity _0; + public FloatT() { tag = LambdaCube.IR.TextureDataType.Tag.FloatT; } + }; + class IntT : LambdaCube.IR.TextureDataType { + public global::LambdaCube.IR.ColorArity _0; + public IntT() { tag = LambdaCube.IR.TextureDataType.Tag.IntT; } + }; + class WordT : LambdaCube.IR.TextureDataType { + public global::LambdaCube.IR.ColorArity _0; + public WordT() { tag = LambdaCube.IR.TextureDataType.Tag.WordT; } + }; + } + class TextureType { + public enum Tag { + Texture1D, + Texture2D, + Texture3D, + TextureCube, + TextureRect, + Texture2DMS, + TextureBuffer + }; + public Tag tag; + }; + + namespace data { + class Texture1D : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public int _1; + public Texture1D() { tag = LambdaCube.IR.TextureType.Tag.Texture1D; } + }; + class Texture2D : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public int _1; + public Texture2D() { tag = LambdaCube.IR.TextureType.Tag.Texture2D; } + }; + class Texture3D : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public Texture3D() { tag = LambdaCube.IR.TextureType.Tag.Texture3D; } + }; + class TextureCube : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public TextureCube() { tag = LambdaCube.IR.TextureType.Tag.TextureCube; } + }; + class TextureRect : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public TextureRect() { tag = LambdaCube.IR.TextureType.Tag.TextureRect; } + }; + class Texture2DMS : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public int _1; + public int _2; + public bool _3; + public Texture2DMS() { tag = LambdaCube.IR.TextureType.Tag.Texture2DMS; } + }; + class TextureBuffer : LambdaCube.IR.TextureType { + public global::LambdaCube.IR.TextureDataType _0; + public TextureBuffer() { tag = LambdaCube.IR.TextureType.Tag.TextureBuffer; } + }; + } + class MipMap { + public enum Tag { + Mip, + NoMip, + AutoMip + }; + public Tag tag; + }; + + namespace data { + class Mip : LambdaCube.IR.MipMap { + public int _0; + public int _1; + public Mip() { tag = LambdaCube.IR.MipMap.Tag.Mip; } + }; + class AutoMip : LambdaCube.IR.MipMap { + public int _0; + public int _1; + public AutoMip() { tag = LambdaCube.IR.MipMap.Tag.AutoMip; } + }; + } + class Filter { + public enum Tag { + Nearest, + Linear, + NearestMipmapNearest, + NearestMipmapLinear, + LinearMipmapNearest, + LinearMipmapLinear + }; + public Tag tag; + }; + + namespace data { + } + class EdgeMode { + public enum Tag { + Repeat, + MirroredRepeat, + ClampToEdge, + ClampToBorder + }; + public Tag tag; + }; + + namespace data { + } + class ImageSemantic { + public enum Tag { + Depth, + Stencil, + Color + }; + public Tag tag; + }; + + namespace data { + } + class ImageRef { + public enum Tag { + TextureImage, + Framebuffer + }; + public Tag tag; + }; + + namespace data { + class TextureImage : LambdaCube.IR.ImageRef { + public int _0; + public int _1; + public Maybe _2; + public TextureImage() { tag = LambdaCube.IR.ImageRef.Tag.TextureImage; } + }; + class Framebuffer : LambdaCube.IR.ImageRef { + public global::LambdaCube.IR.ImageSemantic _0; + public Framebuffer() { tag = LambdaCube.IR.ImageRef.Tag.Framebuffer; } + }; + } + class ClearImage { + public enum Tag { + ClearImage + }; + public Tag tag; + }; + + namespace data { + class ClearImage : LambdaCube.IR.ClearImage { + public global::LambdaCube.IR.ImageSemantic imageSemantic; + public global::LambdaCube.IR.Value clearValue; + public ClearImage() { tag = LambdaCube.IR.ClearImage.Tag.ClearImage; } + }; + } + class Command { + public enum Tag { + SetRasterContext, + SetAccumulationContext, + SetRenderTarget, + SetProgram, + SetSamplerUniform, + SetTexture, + SetSampler, + RenderSlot, + RenderStream, + ClearRenderTarget, + GenerateMipMap, + SaveImage, + LoadImage + }; + public Tag tag; + }; + + namespace data { + class SetRasterContext : LambdaCube.IR.Command { + public global::LambdaCube.IR.RasterContext _0; + public SetRasterContext() { tag = LambdaCube.IR.Command.Tag.SetRasterContext; } + }; + class SetAccumulationContext : LambdaCube.IR.Command { + public global::LambdaCube.IR.AccumulationContext _0; + public SetAccumulationContext() { tag = LambdaCube.IR.Command.Tag.SetAccumulationContext; } + }; + class SetRenderTarget : LambdaCube.IR.Command { + public int _0; + public SetRenderTarget() { tag = LambdaCube.IR.Command.Tag.SetRenderTarget; } + }; + class SetProgram : LambdaCube.IR.Command { + public int _0; + public SetProgram() { tag = LambdaCube.IR.Command.Tag.SetProgram; } + }; + class SetSamplerUniform : LambdaCube.IR.Command { + public string _0; + public int _1; + public SetSamplerUniform() { tag = LambdaCube.IR.Command.Tag.SetSamplerUniform; } + }; + class SetTexture : LambdaCube.IR.Command { + public int _0; + public int _1; + public SetTexture() { tag = LambdaCube.IR.Command.Tag.SetTexture; } + }; + class SetSampler : LambdaCube.IR.Command { + public int _0; + public Maybe _1; + public SetSampler() { tag = LambdaCube.IR.Command.Tag.SetSampler; } + }; + class RenderSlot : LambdaCube.IR.Command { + public int _0; + public RenderSlot() { tag = LambdaCube.IR.Command.Tag.RenderSlot; } + }; + class RenderStream : LambdaCube.IR.Command { + public int _0; + public RenderStream() { tag = LambdaCube.IR.Command.Tag.RenderStream; } + }; + class ClearRenderTarget : LambdaCube.IR.Command { + public List _0; + public ClearRenderTarget() { tag = LambdaCube.IR.Command.Tag.ClearRenderTarget; } + }; + class GenerateMipMap : LambdaCube.IR.Command { + public int _0; + public GenerateMipMap() { tag = LambdaCube.IR.Command.Tag.GenerateMipMap; } + }; + class SaveImage : LambdaCube.IR.Command { + public int _0; + public global::LambdaCube.IR.ImageRef _1; + public SaveImage() { tag = LambdaCube.IR.Command.Tag.SaveImage; } + }; + class LoadImage : LambdaCube.IR.Command { + public global::LambdaCube.IR.ImageRef _0; + public int _1; + public LoadImage() { tag = LambdaCube.IR.Command.Tag.LoadImage; } + }; + } + class SamplerDescriptor { + public enum Tag { + SamplerDescriptor + }; + public Tag tag; + }; + + namespace data { + class SamplerDescriptor : LambdaCube.IR.SamplerDescriptor { + public global::LambdaCube.IR.EdgeMode samplerWrapS; + public Maybe samplerWrapT; + public Maybe samplerWrapR; + public global::LambdaCube.IR.Filter samplerMinFilter; + public global::LambdaCube.IR.Filter samplerMagFilter; + public global::LambdaCube.IR.Value samplerBorderColor; + public Maybe samplerMinLod; + public Maybe samplerMaxLod; + public float samplerLodBias; + public Maybe samplerCompareFunc; + public SamplerDescriptor() { tag = LambdaCube.IR.SamplerDescriptor.Tag.SamplerDescriptor; } + }; + } + class TextureDescriptor { + public enum Tag { + TextureDescriptor + }; + public Tag tag; + }; + + namespace data { + class TextureDescriptor : LambdaCube.IR.TextureDescriptor { + public global::LambdaCube.IR.TextureType textureType; + public global::LambdaCube.IR.Value textureSize; + public global::LambdaCube.IR.ImageSemantic textureSemantic; + public global::LambdaCube.IR.SamplerDescriptor textureSampler; + public int textureBaseLevel; + public int textureMaxLevel; + public TextureDescriptor() { tag = LambdaCube.IR.TextureDescriptor.Tag.TextureDescriptor; } + }; + } + class Parameter { + public enum Tag { + Parameter + }; + public Tag tag; + }; + + namespace data { + class Parameter : LambdaCube.IR.Parameter { + public string name; + public global::LambdaCube.IR.InputType ty; + public Parameter() { tag = LambdaCube.IR.Parameter.Tag.Parameter; } + }; + } + class Program { + public enum Tag { + Program + }; + public Tag tag; + }; + + namespace data { + class Program : LambdaCube.IR.Program { + public Dictionary programUniforms; + public Dictionary programStreams; + public Dictionary programInTextures; + public List programOutput; + public string vertexShader; + public Maybe geometryShader; + public string fragmentShader; + public Program() { tag = LambdaCube.IR.Program.Tag.Program; } + }; + } + class Slot { + public enum Tag { + Slot + }; + public Tag tag; + }; + + namespace data { + class Slot : LambdaCube.IR.Slot { + public string slotName; + public Dictionary slotStreams; + public Dictionary slotUniforms; + public global::LambdaCube.IR.FetchPrimitive slotPrimitive; + public List slotPrograms; + public Slot() { tag = LambdaCube.IR.Slot.Tag.Slot; } + }; + } + class StreamData { + public enum Tag { + StreamData + }; + public Tag tag; + }; + + namespace data { + class StreamData : LambdaCube.IR.StreamData { + public Dictionary streamData; + public Dictionary streamType; + public global::LambdaCube.IR.FetchPrimitive streamPrimitive; + public List streamPrograms; + public StreamData() { tag = LambdaCube.IR.StreamData.Tag.StreamData; } + }; + } + class TargetItem { + public enum Tag { + TargetItem + }; + public Tag tag; + }; + + namespace data { + class TargetItem : LambdaCube.IR.TargetItem { + public global::LambdaCube.IR.ImageSemantic targetSemantic; + public Maybe targetRef; + public TargetItem() { tag = LambdaCube.IR.TargetItem.Tag.TargetItem; } + }; + } + class RenderTarget { + public enum Tag { + RenderTarget + }; + public Tag tag; + }; + + namespace data { + class RenderTarget : LambdaCube.IR.RenderTarget { + public List renderTargets; + public RenderTarget() { tag = LambdaCube.IR.RenderTarget.Tag.RenderTarget; } + }; + } + class Backend { + public enum Tag { + WebGL1, + OpenGL33 + }; + public Tag tag; + }; + + namespace data { + } + class Pipeline { + public enum Tag { + Pipeline + }; + public Tag tag; + }; + + namespace data { + class Pipeline : LambdaCube.IR.Pipeline { + public string info; + public global::LambdaCube.IR.Backend backend; + public List textures; + public List samplers; + public List targets; + public List programs; + public List slots; + public List streams; + public List commands; + public Pipeline() { tag = LambdaCube.IR.Pipeline.Tag.Pipeline; } + }; + } + + // JSON deserializer + enum Type { + Int, + Int32, + Word, + Word32, + Float, + Bool, + String, + V2_Int, + V2_Word, + V2_Float, + V2_Bool, + V2_V2_Float, + V2_V3_Float, + V2_V4_Float, + V3_Int, + V3_Word, + V3_Float, + V3_Bool, + V3_V2_Float, + V3_V3_Float, + V3_V4_Float, + V4_Int, + V4_Word, + V4_Float, + V4_Bool, + V4_V2_Float, + V4_V3_Float, + V4_V4_Float, + Array_Int, + Array_Int32, + Array_Word32, + Array_Float, + Array_Bool, + Array_ClearImage, + Array_Command, + Array_Parameter, + Array_Program, + Array_RenderTarget, + Array_SamplerDescriptor, + Array_Slot, + Array_StreamData, + Array_TargetItem, + Array_TextureDescriptor, + List_FragmentOperation, + Maybe_Int, + Maybe_Float, + Maybe_String, + Maybe_ComparisonFunction, + Maybe_EdgeMode, + Maybe_ImageRef, + Map_String_ArrayValue, + Map_String_InputType, + Map_String_Parameter, + AccumulationContext, + ArrayValue, + Backend, + BlendEquation, + Blending, + BlendingFactor, + ClearImage, + ColorArity, + Command, + ComparisonFunction, + CullMode, + EdgeMode, + FetchPrimitive, + Filter, + FragmentOperation, + FrontFace, + ImageRef, + ImageSemantic, + InputType, + LogicOperation, + MipMap, + OutputPrimitive, + Parameter, + Pipeline, + PointSize, + PointSpriteCoordOrigin, + PolygonMode, + PolygonOffset, + Program, + ProvokingVertex, + RasterContext, + RenderTarget, + SamplerDescriptor, + Slot, + StencilOperation, + StencilOps, + StencilTest, + StencilTests, + StreamData, + TargetItem, + TextureDataType, + TextureDescriptor, + TextureType, + Value + } + + class Loader { + public static object fromJSON(Type type, JToken obj) { + switch (type) { + case Type.Int: return (int)obj; + case Type.Int32: return (int)obj; + case Type.Word: return (uint)obj; + case Type.Word32: return (uint)obj; + case Type.Float: return (float)obj; + case Type.Bool: return (bool)obj; + case Type.String: return (string)obj; + case Type.V2_Int: + return new V2 + { x = (int)fromJSON(Type.Int,obj["x"]) + , y = (int)fromJSON(Type.Int,obj["y"]) + }; + case Type.V2_Word: + return new V2 + { x = (uint)fromJSON(Type.Word,obj["x"]) + , y = (uint)fromJSON(Type.Word,obj["y"]) + }; + case Type.V2_Float: + return new V2 + { x = (float)fromJSON(Type.Float,obj["x"]) + , y = (float)fromJSON(Type.Float,obj["y"]) + }; + case Type.V2_Bool: + return new V2 + { x = (bool)fromJSON(Type.Bool,obj["x"]) + , y = (bool)fromJSON(Type.Bool,obj["y"]) + }; + case Type.V2_V2_Float: + return new V2> + { x = (V2)fromJSON(Type.V2_Float,obj["x"]) + , y = (V2)fromJSON(Type.V2_Float,obj["y"]) + }; + case Type.V2_V3_Float: + return new V2> + { x = (V3)fromJSON(Type.V3_Float,obj["x"]) + , y = (V3)fromJSON(Type.V3_Float,obj["y"]) + }; + case Type.V2_V4_Float: + return new V2> + { x = (V4)fromJSON(Type.V4_Float,obj["x"]) + , y = (V4)fromJSON(Type.V4_Float,obj["y"]) + }; + case Type.V3_Int: + return new V3 + { x = (int)fromJSON(Type.Int,obj["x"]) + , y = (int)fromJSON(Type.Int,obj["y"]) + , z = (int)fromJSON(Type.Int,obj["z"]) + }; + case Type.V3_Word: + return new V3 + { x = (uint)fromJSON(Type.Word,obj["x"]) + , y = (uint)fromJSON(Type.Word,obj["y"]) + , z = (uint)fromJSON(Type.Word,obj["z"]) + }; + case Type.V3_Float: + return new V3 + { x = (float)fromJSON(Type.Float,obj["x"]) + , y = (float)fromJSON(Type.Float,obj["y"]) + , z = (float)fromJSON(Type.Float,obj["z"]) + }; + case Type.V3_Bool: + return new V3 + { x = (bool)fromJSON(Type.Bool,obj["x"]) + , y = (bool)fromJSON(Type.Bool,obj["y"]) + , z = (bool)fromJSON(Type.Bool,obj["z"]) + }; + case Type.V3_V2_Float: + return new V3> + { x = (V2)fromJSON(Type.V2_Float,obj["x"]) + , y = (V2)fromJSON(Type.V2_Float,obj["y"]) + , z = (V2)fromJSON(Type.V2_Float,obj["z"]) + }; + case Type.V3_V3_Float: + return new V3> + { x = (V3)fromJSON(Type.V3_Float,obj["x"]) + , y = (V3)fromJSON(Type.V3_Float,obj["y"]) + , z = (V3)fromJSON(Type.V3_Float,obj["z"]) + }; + case Type.V3_V4_Float: + return new V3> + { x = (V4)fromJSON(Type.V4_Float,obj["x"]) + , y = (V4)fromJSON(Type.V4_Float,obj["y"]) + , z = (V4)fromJSON(Type.V4_Float,obj["z"]) + }; + case Type.V4_Int: + return new V4 + { x = (int)fromJSON(Type.Int,obj["x"]) + , y = (int)fromJSON(Type.Int,obj["y"]) + , z = (int)fromJSON(Type.Int,obj["z"]) + , w = (int)fromJSON(Type.Int,obj["w"]) + }; + case Type.V4_Word: + return new V4 + { x = (uint)fromJSON(Type.Word,obj["x"]) + , y = (uint)fromJSON(Type.Word,obj["y"]) + , z = (uint)fromJSON(Type.Word,obj["z"]) + , w = (uint)fromJSON(Type.Word,obj["w"]) + }; + case Type.V4_Float: + return new V4 + { x = (float)fromJSON(Type.Float,obj["x"]) + , y = (float)fromJSON(Type.Float,obj["y"]) + , z = (float)fromJSON(Type.Float,obj["z"]) + , w = (float)fromJSON(Type.Float,obj["w"]) + }; + case Type.V4_Bool: + return new V4 + { x = (bool)fromJSON(Type.Bool,obj["x"]) + , y = (bool)fromJSON(Type.Bool,obj["y"]) + , z = (bool)fromJSON(Type.Bool,obj["z"]) + , w = (bool)fromJSON(Type.Bool,obj["w"]) + }; + case Type.V4_V2_Float: + return new V4> + { x = (V2)fromJSON(Type.V2_Float,obj["x"]) + , y = (V2)fromJSON(Type.V2_Float,obj["y"]) + , z = (V2)fromJSON(Type.V2_Float,obj["z"]) + , w = (V2)fromJSON(Type.V2_Float,obj["w"]) + }; + case Type.V4_V3_Float: + return new V4> + { x = (V3)fromJSON(Type.V3_Float,obj["x"]) + , y = (V3)fromJSON(Type.V3_Float,obj["y"]) + , z = (V3)fromJSON(Type.V3_Float,obj["z"]) + , w = (V3)fromJSON(Type.V3_Float,obj["w"]) + }; + case Type.V4_V4_Float: + return new V4> + { x = (V4)fromJSON(Type.V4_Float,obj["x"]) + , y = (V4)fromJSON(Type.V4_Float,obj["y"]) + , z = (V4)fromJSON(Type.V4_Float,obj["z"]) + , w = (V4)fromJSON(Type.V4_Float,obj["w"]) + }; + case Type.Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList(); + case Type.Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList(); + case Type.Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList(); + case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList(); + case Type.Array_Bool: return ((JArray)obj).Select(x => fromJSON (Type.Bool, x)).ToList(); + case Type.Array_ClearImage: return ((JArray)obj).Select(x => fromJSON (Type.ClearImage, x)).ToList(); + case Type.Array_Command: return ((JArray)obj).Select(x => fromJSON (Type.Command, x)).ToList(); + case Type.Array_Parameter: return ((JArray)obj).Select(x => fromJSON (Type.Parameter, x)).ToList(); + case Type.Array_Program: return ((JArray)obj).Select(x => fromJSON (Type.Program, x)).ToList(); + case Type.Array_RenderTarget: return ((JArray)obj).Select(x => fromJSON (Type.RenderTarget, x)).ToList(); + case Type.Array_SamplerDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.SamplerDescriptor, x)).ToList(); + case Type.Array_Slot: return ((JArray)obj).Select(x => fromJSON (Type.Slot, x)).ToList(); + case Type.Array_StreamData: return ((JArray)obj).Select(x => fromJSON (Type.StreamData, x)).ToList(); + case Type.Array_TargetItem: return ((JArray)obj).Select(x => fromJSON (Type.TargetItem, x)).ToList(); + case Type.Array_TextureDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.TextureDescriptor, x)).ToList(); + case Type.List_FragmentOperation: return ((JArray)obj).Select(x => fromJSON (Type.FragmentOperation, x)).ToList(); + case Type.Maybe_Int: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (int)fromJSON (Type.Int,obj); + } + return m; + } + case Type.Maybe_Float: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (float)fromJSON (Type.Float,obj); + } + return m; + } + case Type.Maybe_String: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (string)fromJSON (Type.String,obj); + } + return m; + } + case Type.Maybe_ComparisonFunction: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (global::LambdaCube.IR.ComparisonFunction)fromJSON (Type.ComparisonFunction,obj); + } + return m; + } + case Type.Maybe_EdgeMode: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (global::LambdaCube.IR.EdgeMode)fromJSON (Type.EdgeMode,obj); + } + return m; + } + case Type.Maybe_ImageRef: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (global::LambdaCube.IR.ImageRef)fromJSON (Type.ImageRef,obj); + } + return m; + } + case Type.Map_String_ArrayValue: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.IR.ArrayValue)fromJSON(Type.ArrayValue,i.Value)); + } + return map; + } + case Type.Map_String_InputType: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.IR.InputType)fromJSON(Type.InputType,i.Value)); + } + return map; + } + case Type.Map_String_Parameter: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.IR.Parameter)fromJSON(Type.Parameter,i.Value)); + } + return map; + } + + case Type.ArrayValue: { + string tag = (string)obj["tag"]; + ArrayValue.Tag tagType; + if (tag == "VBoolArray") { + tagType = ArrayValue.Tag.VBoolArray; + data.VBoolArray tv = new data.VBoolArray(); + tv._0 = (List)fromJSON(Type.Array_Bool,obj["arg0"]); + return tv; + } + else if (tag == "VIntArray") { + tagType = ArrayValue.Tag.VIntArray; + data.VIntArray tv = new data.VIntArray(); + tv._0 = (List)fromJSON(Type.Array_Int32,obj["arg0"]); + return tv; + } + else if (tag == "VWordArray") { + tagType = ArrayValue.Tag.VWordArray; + data.VWordArray tv = new data.VWordArray(); + tv._0 = (List)fromJSON(Type.Array_Word32,obj["arg0"]); + return tv; + } + else if (tag == "VFloatArray") { + tagType = ArrayValue.Tag.VFloatArray; + data.VFloatArray tv = new data.VFloatArray(); + tv._0 = (List)fromJSON(Type.Array_Float,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + ArrayValue o = new ArrayValue(); + o.tag = tagType; + return o; + } + case Type.Value: { + string tag = (string)obj["tag"]; + Value.Tag tagType; + if (tag == "VBool") { + tagType = Value.Tag.VBool; + data.VBool tv = new data.VBool(); + tv._0 = (bool)fromJSON(Type.Bool,obj["arg0"]); + return tv; + } + else if (tag == "VV2B") { + tagType = Value.Tag.VV2B; + data.VV2B tv = new data.VV2B(); + tv._0 = (V2)fromJSON(Type.V2_Bool,obj["arg0"]); + return tv; + } + else if (tag == "VV3B") { + tagType = Value.Tag.VV3B; + data.VV3B tv = new data.VV3B(); + tv._0 = (V3)fromJSON(Type.V3_Bool,obj["arg0"]); + return tv; + } + else if (tag == "VV4B") { + tagType = Value.Tag.VV4B; + data.VV4B tv = new data.VV4B(); + tv._0 = (V4)fromJSON(Type.V4_Bool,obj["arg0"]); + return tv; + } + else if (tag == "VWord") { + tagType = Value.Tag.VWord; + data.VWord tv = new data.VWord(); + tv._0 = (uint)fromJSON(Type.Word32,obj["arg0"]); + return tv; + } + else if (tag == "VV2U") { + tagType = Value.Tag.VV2U; + data.VV2U tv = new data.VV2U(); + tv._0 = (V2)fromJSON(Type.V2_Word,obj["arg0"]); + return tv; + } + else if (tag == "VV3U") { + tagType = Value.Tag.VV3U; + data.VV3U tv = new data.VV3U(); + tv._0 = (V3)fromJSON(Type.V3_Word,obj["arg0"]); + return tv; + } + else if (tag == "VV4U") { + tagType = Value.Tag.VV4U; + data.VV4U tv = new data.VV4U(); + tv._0 = (V4)fromJSON(Type.V4_Word,obj["arg0"]); + return tv; + } + else if (tag == "VInt") { + tagType = Value.Tag.VInt; + data.VInt tv = new data.VInt(); + tv._0 = (int)fromJSON(Type.Int32,obj["arg0"]); + return tv; + } + else if (tag == "VV2I") { + tagType = Value.Tag.VV2I; + data.VV2I tv = new data.VV2I(); + tv._0 = (V2)fromJSON(Type.V2_Int,obj["arg0"]); + return tv; + } + else if (tag == "VV3I") { + tagType = Value.Tag.VV3I; + data.VV3I tv = new data.VV3I(); + tv._0 = (V3)fromJSON(Type.V3_Int,obj["arg0"]); + return tv; + } + else if (tag == "VV4I") { + tagType = Value.Tag.VV4I; + data.VV4I tv = new data.VV4I(); + tv._0 = (V4)fromJSON(Type.V4_Int,obj["arg0"]); + return tv; + } + else if (tag == "VFloat") { + tagType = Value.Tag.VFloat; + data.VFloat tv = new data.VFloat(); + tv._0 = (float)fromJSON(Type.Float,obj["arg0"]); + return tv; + } + else if (tag == "VV2F") { + tagType = Value.Tag.VV2F; + data.VV2F tv = new data.VV2F(); + tv._0 = (V2)fromJSON(Type.V2_Float,obj["arg0"]); + return tv; + } + else if (tag == "VV3F") { + tagType = Value.Tag.VV3F; + data.VV3F tv = new data.VV3F(); + tv._0 = (V3)fromJSON(Type.V3_Float,obj["arg0"]); + return tv; + } + else if (tag == "VV4F") { + tagType = Value.Tag.VV4F; + data.VV4F tv = new data.VV4F(); + tv._0 = (V4)fromJSON(Type.V4_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM22F") { + tagType = Value.Tag.VM22F; + data.VM22F tv = new data.VM22F(); + tv._0 = (V2>)fromJSON(Type.V2_V2_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM23F") { + tagType = Value.Tag.VM23F; + data.VM23F tv = new data.VM23F(); + tv._0 = (V3>)fromJSON(Type.V3_V2_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM24F") { + tagType = Value.Tag.VM24F; + data.VM24F tv = new data.VM24F(); + tv._0 = (V4>)fromJSON(Type.V4_V2_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM32F") { + tagType = Value.Tag.VM32F; + data.VM32F tv = new data.VM32F(); + tv._0 = (V2>)fromJSON(Type.V2_V3_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM33F") { + tagType = Value.Tag.VM33F; + data.VM33F tv = new data.VM33F(); + tv._0 = (V3>)fromJSON(Type.V3_V3_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM34F") { + tagType = Value.Tag.VM34F; + data.VM34F tv = new data.VM34F(); + tv._0 = (V4>)fromJSON(Type.V4_V3_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM42F") { + tagType = Value.Tag.VM42F; + data.VM42F tv = new data.VM42F(); + tv._0 = (V2>)fromJSON(Type.V2_V4_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM43F") { + tagType = Value.Tag.VM43F; + data.VM43F tv = new data.VM43F(); + tv._0 = (V3>)fromJSON(Type.V3_V4_Float,obj["arg0"]); + return tv; + } + else if (tag == "VM44F") { + tagType = Value.Tag.VM44F; + data.VM44F tv = new data.VM44F(); + tv._0 = (V4>)fromJSON(Type.V4_V4_Float,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Value o = new Value(); + o.tag = tagType; + return o; + } + case Type.InputType: { + string tag = (string)obj["tag"]; + InputType.Tag tagType; + if (tag == "Bool") { + tagType = InputType.Tag.Bool; + } + else if (tag == "V2B") { + tagType = InputType.Tag.V2B; + } + else if (tag == "V3B") { + tagType = InputType.Tag.V3B; + } + else if (tag == "V4B") { + tagType = InputType.Tag.V4B; + } + else if (tag == "Word") { + tagType = InputType.Tag.Word; + } + else if (tag == "V2U") { + tagType = InputType.Tag.V2U; + } + else if (tag == "V3U") { + tagType = InputType.Tag.V3U; + } + else if (tag == "V4U") { + tagType = InputType.Tag.V4U; + } + else if (tag == "Int") { + tagType = InputType.Tag.Int; + } + else if (tag == "V2I") { + tagType = InputType.Tag.V2I; + } + else if (tag == "V3I") { + tagType = InputType.Tag.V3I; + } + else if (tag == "V4I") { + tagType = InputType.Tag.V4I; + } + else if (tag == "Float") { + tagType = InputType.Tag.Float; + } + else if (tag == "V2F") { + tagType = InputType.Tag.V2F; + } + else if (tag == "V3F") { + tagType = InputType.Tag.V3F; + } + else if (tag == "V4F") { + tagType = InputType.Tag.V4F; + } + else if (tag == "M22F") { + tagType = InputType.Tag.M22F; + } + else if (tag == "M23F") { + tagType = InputType.Tag.M23F; + } + else if (tag == "M24F") { + tagType = InputType.Tag.M24F; + } + else if (tag == "M32F") { + tagType = InputType.Tag.M32F; + } + else if (tag == "M33F") { + tagType = InputType.Tag.M33F; + } + else if (tag == "M34F") { + tagType = InputType.Tag.M34F; + } + else if (tag == "M42F") { + tagType = InputType.Tag.M42F; + } + else if (tag == "M43F") { + tagType = InputType.Tag.M43F; + } + else if (tag == "M44F") { + tagType = InputType.Tag.M44F; + } + else if (tag == "STexture1D") { + tagType = InputType.Tag.STexture1D; + } + else if (tag == "STexture2D") { + tagType = InputType.Tag.STexture2D; + } + else if (tag == "STextureCube") { + tagType = InputType.Tag.STextureCube; + } + else if (tag == "STexture1DArray") { + tagType = InputType.Tag.STexture1DArray; + } + else if (tag == "STexture2DArray") { + tagType = InputType.Tag.STexture2DArray; + } + else if (tag == "STexture2DRect") { + tagType = InputType.Tag.STexture2DRect; + } + else if (tag == "FTexture1D") { + tagType = InputType.Tag.FTexture1D; + } + else if (tag == "FTexture2D") { + tagType = InputType.Tag.FTexture2D; + } + else if (tag == "FTexture3D") { + tagType = InputType.Tag.FTexture3D; + } + else if (tag == "FTextureCube") { + tagType = InputType.Tag.FTextureCube; + } + else if (tag == "FTexture1DArray") { + tagType = InputType.Tag.FTexture1DArray; + } + else if (tag == "FTexture2DArray") { + tagType = InputType.Tag.FTexture2DArray; + } + else if (tag == "FTexture2DMS") { + tagType = InputType.Tag.FTexture2DMS; + } + else if (tag == "FTexture2DMSArray") { + tagType = InputType.Tag.FTexture2DMSArray; + } + else if (tag == "FTextureBuffer") { + tagType = InputType.Tag.FTextureBuffer; + } + else if (tag == "FTexture2DRect") { + tagType = InputType.Tag.FTexture2DRect; + } + else if (tag == "ITexture1D") { + tagType = InputType.Tag.ITexture1D; + } + else if (tag == "ITexture2D") { + tagType = InputType.Tag.ITexture2D; + } + else if (tag == "ITexture3D") { + tagType = InputType.Tag.ITexture3D; + } + else if (tag == "ITextureCube") { + tagType = InputType.Tag.ITextureCube; + } + else if (tag == "ITexture1DArray") { + tagType = InputType.Tag.ITexture1DArray; + } + else if (tag == "ITexture2DArray") { + tagType = InputType.Tag.ITexture2DArray; + } + else if (tag == "ITexture2DMS") { + tagType = InputType.Tag.ITexture2DMS; + } + else if (tag == "ITexture2DMSArray") { + tagType = InputType.Tag.ITexture2DMSArray; + } + else if (tag == "ITextureBuffer") { + tagType = InputType.Tag.ITextureBuffer; + } + else if (tag == "ITexture2DRect") { + tagType = InputType.Tag.ITexture2DRect; + } + else if (tag == "UTexture1D") { + tagType = InputType.Tag.UTexture1D; + } + else if (tag == "UTexture2D") { + tagType = InputType.Tag.UTexture2D; + } + else if (tag == "UTexture3D") { + tagType = InputType.Tag.UTexture3D; + } + else if (tag == "UTextureCube") { + tagType = InputType.Tag.UTextureCube; + } + else if (tag == "UTexture1DArray") { + tagType = InputType.Tag.UTexture1DArray; + } + else if (tag == "UTexture2DArray") { + tagType = InputType.Tag.UTexture2DArray; + } + else if (tag == "UTexture2DMS") { + tagType = InputType.Tag.UTexture2DMS; + } + else if (tag == "UTexture2DMSArray") { + tagType = InputType.Tag.UTexture2DMSArray; + } + else if (tag == "UTextureBuffer") { + tagType = InputType.Tag.UTextureBuffer; + } + else if (tag == "UTexture2DRect") { + tagType = InputType.Tag.UTexture2DRect; + } + else throw new Exception("unknown constructor: " + tag); + InputType o = new InputType(); + o.tag = tagType; + return o; + } + case Type.PointSpriteCoordOrigin: { + string tag = (string)obj["tag"]; + PointSpriteCoordOrigin.Tag tagType; + if (tag == "LowerLeft") { + tagType = PointSpriteCoordOrigin.Tag.LowerLeft; + } + else if (tag == "UpperLeft") { + tagType = PointSpriteCoordOrigin.Tag.UpperLeft; + } + else throw new Exception("unknown constructor: " + tag); + PointSpriteCoordOrigin o = new PointSpriteCoordOrigin(); + o.tag = tagType; + return o; + } + case Type.PointSize: { + string tag = (string)obj["tag"]; + PointSize.Tag tagType; + if (tag == "PointSize") { + tagType = PointSize.Tag.PointSize; + data.PointSize tv = new data.PointSize(); + tv._0 = (float)fromJSON(Type.Float,obj["arg0"]); + return tv; + } + else if (tag == "ProgramPointSize") { + tagType = PointSize.Tag.ProgramPointSize; + } + else throw new Exception("unknown constructor: " + tag); + PointSize o = new PointSize(); + o.tag = tagType; + return o; + } + case Type.PolygonOffset: { + string tag = (string)obj["tag"]; + PolygonOffset.Tag tagType; + if (tag == "NoOffset") { + tagType = PolygonOffset.Tag.NoOffset; + } + else if (tag == "Offset") { + tagType = PolygonOffset.Tag.Offset; + data.Offset tv = new data.Offset(); + tv._0 = (float)fromJSON(Type.Float,obj["arg0"]); + tv._1 = (float)fromJSON(Type.Float,obj["arg1"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + PolygonOffset o = new PolygonOffset(); + o.tag = tagType; + return o; + } + case Type.FrontFace: { + string tag = (string)obj["tag"]; + FrontFace.Tag tagType; + if (tag == "CCW") { + tagType = FrontFace.Tag.CCW; + } + else if (tag == "CW") { + tagType = FrontFace.Tag.CW; + } + else throw new Exception("unknown constructor: " + tag); + FrontFace o = new FrontFace(); + o.tag = tagType; + return o; + } + case Type.PolygonMode: { + string tag = (string)obj["tag"]; + PolygonMode.Tag tagType; + if (tag == "PolygonPoint") { + tagType = PolygonMode.Tag.PolygonPoint; + data.PolygonPoint tv = new data.PolygonPoint(); + tv._0 = (global::LambdaCube.IR.PointSize)fromJSON(Type.PointSize,obj["arg0"]); + return tv; + } + else if (tag == "PolygonLine") { + tagType = PolygonMode.Tag.PolygonLine; + data.PolygonLine tv = new data.PolygonLine(); + tv._0 = (float)fromJSON(Type.Float,obj["arg0"]); + return tv; + } + else if (tag == "PolygonFill") { + tagType = PolygonMode.Tag.PolygonFill; + } + else throw new Exception("unknown constructor: " + tag); + PolygonMode o = new PolygonMode(); + o.tag = tagType; + return o; + } + case Type.ProvokingVertex: { + string tag = (string)obj["tag"]; + ProvokingVertex.Tag tagType; + if (tag == "FirstVertex") { + tagType = ProvokingVertex.Tag.FirstVertex; + } + else if (tag == "LastVertex") { + tagType = ProvokingVertex.Tag.LastVertex; + } + else throw new Exception("unknown constructor: " + tag); + ProvokingVertex o = new ProvokingVertex(); + o.tag = tagType; + return o; + } + case Type.CullMode: { + string tag = (string)obj["tag"]; + CullMode.Tag tagType; + if (tag == "CullNone") { + tagType = CullMode.Tag.CullNone; + } + else if (tag == "CullFront") { + tagType = CullMode.Tag.CullFront; + data.CullFront tv = new data.CullFront(); + tv._0 = (global::LambdaCube.IR.FrontFace)fromJSON(Type.FrontFace,obj["arg0"]); + return tv; + } + else if (tag == "CullBack") { + tagType = CullMode.Tag.CullBack; + data.CullBack tv = new data.CullBack(); + tv._0 = (global::LambdaCube.IR.FrontFace)fromJSON(Type.FrontFace,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + CullMode o = new CullMode(); + o.tag = tagType; + return o; + } + case Type.ComparisonFunction: { + string tag = (string)obj["tag"]; + ComparisonFunction.Tag tagType; + if (tag == "Never") { + tagType = ComparisonFunction.Tag.Never; + } + else if (tag == "Less") { + tagType = ComparisonFunction.Tag.Less; + } + else if (tag == "Equal") { + tagType = ComparisonFunction.Tag.Equal; + } + else if (tag == "Lequal") { + tagType = ComparisonFunction.Tag.Lequal; + } + else if (tag == "Greater") { + tagType = ComparisonFunction.Tag.Greater; + } + else if (tag == "Notequal") { + tagType = ComparisonFunction.Tag.Notequal; + } + else if (tag == "Gequal") { + tagType = ComparisonFunction.Tag.Gequal; + } + else if (tag == "Always") { + tagType = ComparisonFunction.Tag.Always; + } + else throw new Exception("unknown constructor: " + tag); + ComparisonFunction o = new ComparisonFunction(); + o.tag = tagType; + return o; + } + case Type.StencilOperation: { + string tag = (string)obj["tag"]; + StencilOperation.Tag tagType; + if (tag == "OpZero") { + tagType = StencilOperation.Tag.OpZero; + } + else if (tag == "OpKeep") { + tagType = StencilOperation.Tag.OpKeep; + } + else if (tag == "OpReplace") { + tagType = StencilOperation.Tag.OpReplace; + } + else if (tag == "OpIncr") { + tagType = StencilOperation.Tag.OpIncr; + } + else if (tag == "OpIncrWrap") { + tagType = StencilOperation.Tag.OpIncrWrap; + } + else if (tag == "OpDecr") { + tagType = StencilOperation.Tag.OpDecr; + } + else if (tag == "OpDecrWrap") { + tagType = StencilOperation.Tag.OpDecrWrap; + } + else if (tag == "OpInvert") { + tagType = StencilOperation.Tag.OpInvert; + } + else throw new Exception("unknown constructor: " + tag); + StencilOperation o = new StencilOperation(); + o.tag = tagType; + return o; + } + case Type.BlendEquation: { + string tag = (string)obj["tag"]; + BlendEquation.Tag tagType; + if (tag == "FuncAdd") { + tagType = BlendEquation.Tag.FuncAdd; + } + else if (tag == "FuncSubtract") { + tagType = BlendEquation.Tag.FuncSubtract; + } + else if (tag == "FuncReverseSubtract") { + tagType = BlendEquation.Tag.FuncReverseSubtract; + } + else if (tag == "Min") { + tagType = BlendEquation.Tag.Min; + } + else if (tag == "Max") { + tagType = BlendEquation.Tag.Max; + } + else throw new Exception("unknown constructor: " + tag); + BlendEquation o = new BlendEquation(); + o.tag = tagType; + return o; + } + case Type.BlendingFactor: { + string tag = (string)obj["tag"]; + BlendingFactor.Tag tagType; + if (tag == "Zero") { + tagType = BlendingFactor.Tag.Zero; + } + else if (tag == "One") { + tagType = BlendingFactor.Tag.One; + } + else if (tag == "SrcColor") { + tagType = BlendingFactor.Tag.SrcColor; + } + else if (tag == "OneMinusSrcColor") { + tagType = BlendingFactor.Tag.OneMinusSrcColor; + } + else if (tag == "DstColor") { + tagType = BlendingFactor.Tag.DstColor; + } + else if (tag == "OneMinusDstColor") { + tagType = BlendingFactor.Tag.OneMinusDstColor; + } + else if (tag == "SrcAlpha") { + tagType = BlendingFactor.Tag.SrcAlpha; + } + else if (tag == "OneMinusSrcAlpha") { + tagType = BlendingFactor.Tag.OneMinusSrcAlpha; + } + else if (tag == "DstAlpha") { + tagType = BlendingFactor.Tag.DstAlpha; + } + else if (tag == "OneMinusDstAlpha") { + tagType = BlendingFactor.Tag.OneMinusDstAlpha; + } + else if (tag == "ConstantColor") { + tagType = BlendingFactor.Tag.ConstantColor; + } + else if (tag == "OneMinusConstantColor") { + tagType = BlendingFactor.Tag.OneMinusConstantColor; + } + else if (tag == "ConstantAlpha") { + tagType = BlendingFactor.Tag.ConstantAlpha; + } + else if (tag == "OneMinusConstantAlpha") { + tagType = BlendingFactor.Tag.OneMinusConstantAlpha; + } + else if (tag == "SrcAlphaSaturate") { + tagType = BlendingFactor.Tag.SrcAlphaSaturate; + } + else throw new Exception("unknown constructor: " + tag); + BlendingFactor o = new BlendingFactor(); + o.tag = tagType; + return o; + } + case Type.LogicOperation: { + string tag = (string)obj["tag"]; + LogicOperation.Tag tagType; + if (tag == "Clear") { + tagType = LogicOperation.Tag.Clear; + } + else if (tag == "And") { + tagType = LogicOperation.Tag.And; + } + else if (tag == "AndReverse") { + tagType = LogicOperation.Tag.AndReverse; + } + else if (tag == "Copy") { + tagType = LogicOperation.Tag.Copy; + } + else if (tag == "AndInverted") { + tagType = LogicOperation.Tag.AndInverted; + } + else if (tag == "Noop") { + tagType = LogicOperation.Tag.Noop; + } + else if (tag == "Xor") { + tagType = LogicOperation.Tag.Xor; + } + else if (tag == "Or") { + tagType = LogicOperation.Tag.Or; + } + else if (tag == "Nor") { + tagType = LogicOperation.Tag.Nor; + } + else if (tag == "Equiv") { + tagType = LogicOperation.Tag.Equiv; + } + else if (tag == "Invert") { + tagType = LogicOperation.Tag.Invert; + } + else if (tag == "OrReverse") { + tagType = LogicOperation.Tag.OrReverse; + } + else if (tag == "CopyInverted") { + tagType = LogicOperation.Tag.CopyInverted; + } + else if (tag == "OrInverted") { + tagType = LogicOperation.Tag.OrInverted; + } + else if (tag == "Nand") { + tagType = LogicOperation.Tag.Nand; + } + else if (tag == "Set") { + tagType = LogicOperation.Tag.Set; + } + else throw new Exception("unknown constructor: " + tag); + LogicOperation o = new LogicOperation(); + o.tag = tagType; + return o; + } + case Type.StencilOps: { + string tag = (string)obj["tag"]; + StencilOps.Tag tagType; + if (tag == "StencilOps") { + tagType = StencilOps.Tag.StencilOps; + data.StencilOps tv = new data.StencilOps(); + tv.frontStencilOp = (global::LambdaCube.IR.StencilOperation)fromJSON(Type.StencilOperation,obj["frontStencilOp"]); + tv.backStencilOp = (global::LambdaCube.IR.StencilOperation)fromJSON(Type.StencilOperation,obj["backStencilOp"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + StencilOps o = new StencilOps(); + o.tag = tagType; + return o; + } + case Type.StencilTest: { + string tag = (string)obj["tag"]; + StencilTest.Tag tagType; + if (tag == "StencilTest") { + tagType = StencilTest.Tag.StencilTest; + data.StencilTest tv = new data.StencilTest(); + tv.stencilComparision = (global::LambdaCube.IR.ComparisonFunction)fromJSON(Type.ComparisonFunction,obj["stencilComparision"]); + tv.stencilReference = (int)fromJSON(Type.Int32,obj["stencilReference"]); + tv.stencilMask = (uint)fromJSON(Type.Word32,obj["stencilMask"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + StencilTest o = new StencilTest(); + o.tag = tagType; + return o; + } + case Type.StencilTests: { + string tag = (string)obj["tag"]; + StencilTests.Tag tagType; + if (tag == "StencilTests") { + tagType = StencilTests.Tag.StencilTests; + data.StencilTests tv = new data.StencilTests(); + tv._0 = (global::LambdaCube.IR.StencilTest)fromJSON(Type.StencilTest,obj["arg0"]); + tv._1 = (global::LambdaCube.IR.StencilTest)fromJSON(Type.StencilTest,obj["arg1"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + StencilTests o = new StencilTests(); + o.tag = tagType; + return o; + } + case Type.FetchPrimitive: { + string tag = (string)obj["tag"]; + FetchPrimitive.Tag tagType; + if (tag == "Points") { + tagType = FetchPrimitive.Tag.Points; + } + else if (tag == "Lines") { + tagType = FetchPrimitive.Tag.Lines; + } + else if (tag == "Triangles") { + tagType = FetchPrimitive.Tag.Triangles; + } + else if (tag == "LinesAdjacency") { + tagType = FetchPrimitive.Tag.LinesAdjacency; + } + else if (tag == "TrianglesAdjacency") { + tagType = FetchPrimitive.Tag.TrianglesAdjacency; + } + else throw new Exception("unknown constructor: " + tag); + FetchPrimitive o = new FetchPrimitive(); + o.tag = tagType; + return o; + } + case Type.OutputPrimitive: { + string tag = (string)obj["tag"]; + OutputPrimitive.Tag tagType; + if (tag == "TrianglesOutput") { + tagType = OutputPrimitive.Tag.TrianglesOutput; + } + else if (tag == "LinesOutput") { + tagType = OutputPrimitive.Tag.LinesOutput; + } + else if (tag == "PointsOutput") { + tagType = OutputPrimitive.Tag.PointsOutput; + } + else throw new Exception("unknown constructor: " + tag); + OutputPrimitive o = new OutputPrimitive(); + o.tag = tagType; + return o; + } + case Type.ColorArity: { + string tag = (string)obj["tag"]; + ColorArity.Tag tagType; + if (tag == "Red") { + tagType = ColorArity.Tag.Red; + } + else if (tag == "RG") { + tagType = ColorArity.Tag.RG; + } + else if (tag == "RGB") { + tagType = ColorArity.Tag.RGB; + } + else if (tag == "RGBA") { + tagType = ColorArity.Tag.RGBA; + } + else throw new Exception("unknown constructor: " + tag); + ColorArity o = new ColorArity(); + o.tag = tagType; + return o; + } + case Type.Blending: { + string tag = (string)obj["tag"]; + Blending.Tag tagType; + if (tag == "NoBlending") { + tagType = Blending.Tag.NoBlending; + } + else if (tag == "BlendLogicOp") { + tagType = Blending.Tag.BlendLogicOp; + data.BlendLogicOp tv = new data.BlendLogicOp(); + tv._0 = (global::LambdaCube.IR.LogicOperation)fromJSON(Type.LogicOperation,obj["arg0"]); + return tv; + } + else if (tag == "Blend") { + tagType = Blending.Tag.Blend; + data.Blend tv = new data.Blend(); + tv.colorEqSrc = (global::LambdaCube.IR.BlendEquation)fromJSON(Type.BlendEquation,obj["colorEqSrc"]); + tv.alphaEqSrc = (global::LambdaCube.IR.BlendEquation)fromJSON(Type.BlendEquation,obj["alphaEqSrc"]); + tv.colorFSrc = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["colorFSrc"]); + tv.colorFDst = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["colorFDst"]); + tv.alphaFSrc = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["alphaFSrc"]); + tv.alphaFDst = (global::LambdaCube.IR.BlendingFactor)fromJSON(Type.BlendingFactor,obj["alphaFDst"]); + tv.color = (V4)fromJSON(Type.V4_Float,obj["color"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Blending o = new Blending(); + o.tag = tagType; + return o; + } + case Type.RasterContext: { + string tag = (string)obj["tag"]; + RasterContext.Tag tagType; + if (tag == "PointCtx") { + tagType = RasterContext.Tag.PointCtx; + data.PointCtx tv = new data.PointCtx(); + tv._0 = (global::LambdaCube.IR.PointSize)fromJSON(Type.PointSize,obj["arg0"]); + tv._1 = (float)fromJSON(Type.Float,obj["arg1"]); + tv._2 = (global::LambdaCube.IR.PointSpriteCoordOrigin)fromJSON(Type.PointSpriteCoordOrigin,obj["arg2"]); + return tv; + } + else if (tag == "LineCtx") { + tagType = RasterContext.Tag.LineCtx; + data.LineCtx tv = new data.LineCtx(); + tv._0 = (float)fromJSON(Type.Float,obj["arg0"]); + tv._1 = (global::LambdaCube.IR.ProvokingVertex)fromJSON(Type.ProvokingVertex,obj["arg1"]); + return tv; + } + else if (tag == "TriangleCtx") { + tagType = RasterContext.Tag.TriangleCtx; + data.TriangleCtx tv = new data.TriangleCtx(); + tv._0 = (global::LambdaCube.IR.CullMode)fromJSON(Type.CullMode,obj["arg0"]); + tv._1 = (global::LambdaCube.IR.PolygonMode)fromJSON(Type.PolygonMode,obj["arg1"]); + tv._2 = (global::LambdaCube.IR.PolygonOffset)fromJSON(Type.PolygonOffset,obj["arg2"]); + tv._3 = (global::LambdaCube.IR.ProvokingVertex)fromJSON(Type.ProvokingVertex,obj["arg3"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + RasterContext o = new RasterContext(); + o.tag = tagType; + return o; + } + case Type.FragmentOperation: { + string tag = (string)obj["tag"]; + FragmentOperation.Tag tagType; + if (tag == "DepthOp") { + tagType = FragmentOperation.Tag.DepthOp; + data.DepthOp tv = new data.DepthOp(); + tv._0 = (global::LambdaCube.IR.ComparisonFunction)fromJSON(Type.ComparisonFunction,obj["arg0"]); + tv._1 = (bool)fromJSON(Type.Bool,obj["arg1"]); + return tv; + } + else if (tag == "StencilOp") { + tagType = FragmentOperation.Tag.StencilOp; + data.StencilOp tv = new data.StencilOp(); + tv._0 = (global::LambdaCube.IR.StencilTests)fromJSON(Type.StencilTests,obj["arg0"]); + tv._1 = (global::LambdaCube.IR.StencilOps)fromJSON(Type.StencilOps,obj["arg1"]); + tv._2 = (global::LambdaCube.IR.StencilOps)fromJSON(Type.StencilOps,obj["arg2"]); + return tv; + } + else if (tag == "ColorOp") { + tagType = FragmentOperation.Tag.ColorOp; + data.ColorOp tv = new data.ColorOp(); + tv._0 = (global::LambdaCube.IR.Blending)fromJSON(Type.Blending,obj["arg0"]); + tv._1 = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["arg1"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + FragmentOperation o = new FragmentOperation(); + o.tag = tagType; + return o; + } + case Type.AccumulationContext: { + string tag = (string)obj["tag"]; + AccumulationContext.Tag tagType; + if (tag == "AccumulationContext") { + tagType = AccumulationContext.Tag.AccumulationContext; + data.AccumulationContext tv = new data.AccumulationContext(); + tv.accViewportName = (Maybe)fromJSON(Type.Maybe_String,obj["accViewportName"]); + tv.accOperations = (List)fromJSON(Type.List_FragmentOperation,obj["accOperations"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + AccumulationContext o = new AccumulationContext(); + o.tag = tagType; + return o; + } + case Type.TextureDataType: { + string tag = (string)obj["tag"]; + TextureDataType.Tag tagType; + if (tag == "FloatT") { + tagType = TextureDataType.Tag.FloatT; + data.FloatT tv = new data.FloatT(); + tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]); + return tv; + } + else if (tag == "IntT") { + tagType = TextureDataType.Tag.IntT; + data.IntT tv = new data.IntT(); + tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]); + return tv; + } + else if (tag == "WordT") { + tagType = TextureDataType.Tag.WordT; + data.WordT tv = new data.WordT(); + tv._0 = (global::LambdaCube.IR.ColorArity)fromJSON(Type.ColorArity,obj["arg0"]); + return tv; + } + else if (tag == "ShadowT") { + tagType = TextureDataType.Tag.ShadowT; + } + else throw new Exception("unknown constructor: " + tag); + TextureDataType o = new TextureDataType(); + o.tag = tagType; + return o; + } + case Type.TextureType: { + string tag = (string)obj["tag"]; + TextureType.Tag tagType; + if (tag == "Texture1D") { + tagType = TextureType.Tag.Texture1D; + data.Texture1D tv = new data.Texture1D(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else if (tag == "Texture2D") { + tagType = TextureType.Tag.Texture2D; + data.Texture2D tv = new data.Texture2D(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else if (tag == "Texture3D") { + tagType = TextureType.Tag.Texture3D; + data.Texture3D tv = new data.Texture3D(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + return tv; + } + else if (tag == "TextureCube") { + tagType = TextureType.Tag.TextureCube; + data.TextureCube tv = new data.TextureCube(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + return tv; + } + else if (tag == "TextureRect") { + tagType = TextureType.Tag.TextureRect; + data.TextureRect tv = new data.TextureRect(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + return tv; + } + else if (tag == "Texture2DMS") { + tagType = TextureType.Tag.Texture2DMS; + data.Texture2DMS tv = new data.Texture2DMS(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + tv._2 = (int)fromJSON(Type.Int,obj["arg2"]); + tv._3 = (bool)fromJSON(Type.Bool,obj["arg3"]); + return tv; + } + else if (tag == "TextureBuffer") { + tagType = TextureType.Tag.TextureBuffer; + data.TextureBuffer tv = new data.TextureBuffer(); + tv._0 = (global::LambdaCube.IR.TextureDataType)fromJSON(Type.TextureDataType,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + TextureType o = new TextureType(); + o.tag = tagType; + return o; + } + case Type.MipMap: { + string tag = (string)obj["tag"]; + MipMap.Tag tagType; + if (tag == "Mip") { + tagType = MipMap.Tag.Mip; + data.Mip tv = new data.Mip(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else if (tag == "NoMip") { + tagType = MipMap.Tag.NoMip; + } + else if (tag == "AutoMip") { + tagType = MipMap.Tag.AutoMip; + data.AutoMip tv = new data.AutoMip(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + MipMap o = new MipMap(); + o.tag = tagType; + return o; + } + case Type.Filter: { + string tag = (string)obj["tag"]; + Filter.Tag tagType; + if (tag == "Nearest") { + tagType = Filter.Tag.Nearest; + } + else if (tag == "Linear") { + tagType = Filter.Tag.Linear; + } + else if (tag == "NearestMipmapNearest") { + tagType = Filter.Tag.NearestMipmapNearest; + } + else if (tag == "NearestMipmapLinear") { + tagType = Filter.Tag.NearestMipmapLinear; + } + else if (tag == "LinearMipmapNearest") { + tagType = Filter.Tag.LinearMipmapNearest; + } + else if (tag == "LinearMipmapLinear") { + tagType = Filter.Tag.LinearMipmapLinear; + } + else throw new Exception("unknown constructor: " + tag); + Filter o = new Filter(); + o.tag = tagType; + return o; + } + case Type.EdgeMode: { + string tag = (string)obj["tag"]; + EdgeMode.Tag tagType; + if (tag == "Repeat") { + tagType = EdgeMode.Tag.Repeat; + } + else if (tag == "MirroredRepeat") { + tagType = EdgeMode.Tag.MirroredRepeat; + } + else if (tag == "ClampToEdge") { + tagType = EdgeMode.Tag.ClampToEdge; + } + else if (tag == "ClampToBorder") { + tagType = EdgeMode.Tag.ClampToBorder; + } + else throw new Exception("unknown constructor: " + tag); + EdgeMode o = new EdgeMode(); + o.tag = tagType; + return o; + } + case Type.ImageSemantic: { + string tag = (string)obj["tag"]; + ImageSemantic.Tag tagType; + if (tag == "Depth") { + tagType = ImageSemantic.Tag.Depth; + } + else if (tag == "Stencil") { + tagType = ImageSemantic.Tag.Stencil; + } + else if (tag == "Color") { + tagType = ImageSemantic.Tag.Color; + } + else throw new Exception("unknown constructor: " + tag); + ImageSemantic o = new ImageSemantic(); + o.tag = tagType; + return o; + } + case Type.ImageRef: { + string tag = (string)obj["tag"]; + ImageRef.Tag tagType; + if (tag == "TextureImage") { + tagType = ImageRef.Tag.TextureImage; + data.TextureImage tv = new data.TextureImage(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + tv._2 = (Maybe)fromJSON(Type.Maybe_Int,obj["arg2"]); + return tv; + } + else if (tag == "Framebuffer") { + tagType = ImageRef.Tag.Framebuffer; + data.Framebuffer tv = new data.Framebuffer(); + tv._0 = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + ImageRef o = new ImageRef(); + o.tag = tagType; + return o; + } + case Type.ClearImage: { + string tag = (string)obj["tag"]; + ClearImage.Tag tagType; + if (tag == "ClearImage") { + tagType = ClearImage.Tag.ClearImage; + data.ClearImage tv = new data.ClearImage(); + tv.imageSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["imageSemantic"]); + tv.clearValue = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["clearValue"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + ClearImage o = new ClearImage(); + o.tag = tagType; + return o; + } + case Type.Command: { + string tag = (string)obj["tag"]; + Command.Tag tagType; + if (tag == "SetRasterContext") { + tagType = Command.Tag.SetRasterContext; + data.SetRasterContext tv = new data.SetRasterContext(); + tv._0 = (global::LambdaCube.IR.RasterContext)fromJSON(Type.RasterContext,obj["arg0"]); + return tv; + } + else if (tag == "SetAccumulationContext") { + tagType = Command.Tag.SetAccumulationContext; + data.SetAccumulationContext tv = new data.SetAccumulationContext(); + tv._0 = (global::LambdaCube.IR.AccumulationContext)fromJSON(Type.AccumulationContext,obj["arg0"]); + return tv; + } + else if (tag == "SetRenderTarget") { + tagType = Command.Tag.SetRenderTarget; + data.SetRenderTarget tv = new data.SetRenderTarget(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + return tv; + } + else if (tag == "SetProgram") { + tagType = Command.Tag.SetProgram; + data.SetProgram tv = new data.SetProgram(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + return tv; + } + else if (tag == "SetSamplerUniform") { + tagType = Command.Tag.SetSamplerUniform; + data.SetSamplerUniform tv = new data.SetSamplerUniform(); + tv._0 = (string)fromJSON(Type.String,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else if (tag == "SetTexture") { + tagType = Command.Tag.SetTexture; + data.SetTexture tv = new data.SetTexture(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else if (tag == "SetSampler") { + tagType = Command.Tag.SetSampler; + data.SetSampler tv = new data.SetSampler(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + tv._1 = (Maybe)fromJSON(Type.Maybe_Int,obj["arg1"]); + return tv; + } + else if (tag == "RenderSlot") { + tagType = Command.Tag.RenderSlot; + data.RenderSlot tv = new data.RenderSlot(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + return tv; + } + else if (tag == "RenderStream") { + tagType = Command.Tag.RenderStream; + data.RenderStream tv = new data.RenderStream(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + return tv; + } + else if (tag == "ClearRenderTarget") { + tagType = Command.Tag.ClearRenderTarget; + data.ClearRenderTarget tv = new data.ClearRenderTarget(); + tv._0 = (List)fromJSON(Type.Array_ClearImage,obj["arg0"]); + return tv; + } + else if (tag == "GenerateMipMap") { + tagType = Command.Tag.GenerateMipMap; + data.GenerateMipMap tv = new data.GenerateMipMap(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + return tv; + } + else if (tag == "SaveImage") { + tagType = Command.Tag.SaveImage; + data.SaveImage tv = new data.SaveImage(); + tv._0 = (int)fromJSON(Type.Int,obj["arg0"]); + tv._1 = (global::LambdaCube.IR.ImageRef)fromJSON(Type.ImageRef,obj["arg1"]); + return tv; + } + else if (tag == "LoadImage") { + tagType = Command.Tag.LoadImage; + data.LoadImage tv = new data.LoadImage(); + tv._0 = (global::LambdaCube.IR.ImageRef)fromJSON(Type.ImageRef,obj["arg0"]); + tv._1 = (int)fromJSON(Type.Int,obj["arg1"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Command o = new Command(); + o.tag = tagType; + return o; + } + case Type.SamplerDescriptor: { + string tag = (string)obj["tag"]; + SamplerDescriptor.Tag tagType; + if (tag == "SamplerDescriptor") { + tagType = SamplerDescriptor.Tag.SamplerDescriptor; + data.SamplerDescriptor tv = new data.SamplerDescriptor(); + tv.samplerWrapS = (global::LambdaCube.IR.EdgeMode)fromJSON(Type.EdgeMode,obj["samplerWrapS"]); + tv.samplerWrapT = (Maybe)fromJSON(Type.Maybe_EdgeMode,obj["samplerWrapT"]); + tv.samplerWrapR = (Maybe)fromJSON(Type.Maybe_EdgeMode,obj["samplerWrapR"]); + tv.samplerMinFilter = (global::LambdaCube.IR.Filter)fromJSON(Type.Filter,obj["samplerMinFilter"]); + tv.samplerMagFilter = (global::LambdaCube.IR.Filter)fromJSON(Type.Filter,obj["samplerMagFilter"]); + tv.samplerBorderColor = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["samplerBorderColor"]); + tv.samplerMinLod = (Maybe)fromJSON(Type.Maybe_Float,obj["samplerMinLod"]); + tv.samplerMaxLod = (Maybe)fromJSON(Type.Maybe_Float,obj["samplerMaxLod"]); + tv.samplerLodBias = (float)fromJSON(Type.Float,obj["samplerLodBias"]); + tv.samplerCompareFunc = (Maybe)fromJSON(Type.Maybe_ComparisonFunction,obj["samplerCompareFunc"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + SamplerDescriptor o = new SamplerDescriptor(); + o.tag = tagType; + return o; + } + case Type.TextureDescriptor: { + string tag = (string)obj["tag"]; + TextureDescriptor.Tag tagType; + if (tag == "TextureDescriptor") { + tagType = TextureDescriptor.Tag.TextureDescriptor; + data.TextureDescriptor tv = new data.TextureDescriptor(); + tv.textureType = (global::LambdaCube.IR.TextureType)fromJSON(Type.TextureType,obj["textureType"]); + tv.textureSize = (global::LambdaCube.IR.Value)fromJSON(Type.Value,obj["textureSize"]); + tv.textureSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["textureSemantic"]); + tv.textureSampler = (global::LambdaCube.IR.SamplerDescriptor)fromJSON(Type.SamplerDescriptor,obj["textureSampler"]); + tv.textureBaseLevel = (int)fromJSON(Type.Int,obj["textureBaseLevel"]); + tv.textureMaxLevel = (int)fromJSON(Type.Int,obj["textureMaxLevel"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + TextureDescriptor o = new TextureDescriptor(); + o.tag = tagType; + return o; + } + case Type.Parameter: { + string tag = (string)obj["tag"]; + Parameter.Tag tagType; + if (tag == "Parameter") { + tagType = Parameter.Tag.Parameter; + data.Parameter tv = new data.Parameter(); + tv.name = (string)fromJSON(Type.String,obj["name"]); + tv.ty = (global::LambdaCube.IR.InputType)fromJSON(Type.InputType,obj["ty"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Parameter o = new Parameter(); + o.tag = tagType; + return o; + } + case Type.Program: { + string tag = (string)obj["tag"]; + Program.Tag tagType; + if (tag == "Program") { + tagType = Program.Tag.Program; + data.Program tv = new data.Program(); + tv.programUniforms = (Dictionary)fromJSON(Type.Map_String_InputType,obj["programUniforms"]); + tv.programStreams = (Dictionary)fromJSON(Type.Map_String_Parameter,obj["programStreams"]); + tv.programInTextures = (Dictionary)fromJSON(Type.Map_String_InputType,obj["programInTextures"]); + tv.programOutput = (List)fromJSON(Type.Array_Parameter,obj["programOutput"]); + tv.vertexShader = (string)fromJSON(Type.String,obj["vertexShader"]); + tv.geometryShader = (Maybe)fromJSON(Type.Maybe_String,obj["geometryShader"]); + tv.fragmentShader = (string)fromJSON(Type.String,obj["fragmentShader"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Program o = new Program(); + o.tag = tagType; + return o; + } + case Type.Slot: { + string tag = (string)obj["tag"]; + Slot.Tag tagType; + if (tag == "Slot") { + tagType = Slot.Tag.Slot; + data.Slot tv = new data.Slot(); + tv.slotName = (string)fromJSON(Type.String,obj["slotName"]); + tv.slotStreams = (Dictionary)fromJSON(Type.Map_String_InputType,obj["slotStreams"]); + tv.slotUniforms = (Dictionary)fromJSON(Type.Map_String_InputType,obj["slotUniforms"]); + tv.slotPrimitive = (global::LambdaCube.IR.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["slotPrimitive"]); + tv.slotPrograms = (List)fromJSON(Type.Array_Int,obj["slotPrograms"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Slot o = new Slot(); + o.tag = tagType; + return o; + } + case Type.StreamData: { + string tag = (string)obj["tag"]; + StreamData.Tag tagType; + if (tag == "StreamData") { + tagType = StreamData.Tag.StreamData; + data.StreamData tv = new data.StreamData(); + tv.streamData = (Dictionary)fromJSON(Type.Map_String_ArrayValue,obj["streamData"]); + tv.streamType = (Dictionary)fromJSON(Type.Map_String_InputType,obj["streamType"]); + tv.streamPrimitive = (global::LambdaCube.IR.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["streamPrimitive"]); + tv.streamPrograms = (List)fromJSON(Type.Array_Int,obj["streamPrograms"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + StreamData o = new StreamData(); + o.tag = tagType; + return o; + } + case Type.TargetItem: { + string tag = (string)obj["tag"]; + TargetItem.Tag tagType; + if (tag == "TargetItem") { + tagType = TargetItem.Tag.TargetItem; + data.TargetItem tv = new data.TargetItem(); + tv.targetSemantic = (global::LambdaCube.IR.ImageSemantic)fromJSON(Type.ImageSemantic,obj["targetSemantic"]); + tv.targetRef = (Maybe)fromJSON(Type.Maybe_ImageRef,obj["targetRef"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + TargetItem o = new TargetItem(); + o.tag = tagType; + return o; + } + case Type.RenderTarget: { + string tag = (string)obj["tag"]; + RenderTarget.Tag tagType; + if (tag == "RenderTarget") { + tagType = RenderTarget.Tag.RenderTarget; + data.RenderTarget tv = new data.RenderTarget(); + tv.renderTargets = (List)fromJSON(Type.Array_TargetItem,obj["renderTargets"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + RenderTarget o = new RenderTarget(); + o.tag = tagType; + return o; + } + case Type.Backend: { + string tag = (string)obj["tag"]; + Backend.Tag tagType; + if (tag == "WebGL1") { + tagType = Backend.Tag.WebGL1; + } + else if (tag == "OpenGL33") { + tagType = Backend.Tag.OpenGL33; + } + else throw new Exception("unknown constructor: " + tag); + Backend o = new Backend(); + o.tag = tagType; + return o; + } + case Type.Pipeline: { + string tag = (string)obj["tag"]; + Pipeline.Tag tagType; + if (tag == "Pipeline") { + tagType = Pipeline.Tag.Pipeline; + data.Pipeline tv = new data.Pipeline(); + tv.info = (string)fromJSON(Type.String,obj["info"]); + tv.backend = (global::LambdaCube.IR.Backend)fromJSON(Type.Backend,obj["backend"]); + tv.textures = (List)fromJSON(Type.Array_TextureDescriptor,obj["textures"]); + tv.samplers = (List)fromJSON(Type.Array_SamplerDescriptor,obj["samplers"]); + tv.targets = (List)fromJSON(Type.Array_RenderTarget,obj["targets"]); + tv.programs = (List)fromJSON(Type.Array_Program,obj["programs"]); + tv.slots = (List)fromJSON(Type.Array_Slot,obj["slots"]); + tv.streams = (List)fromJSON(Type.Array_StreamData,obj["streams"]); + tv.commands = (List)fromJSON(Type.Array_Command,obj["commands"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Pipeline o = new Pipeline(); + o.tag = tagType; + return o; + } + } + throw new Exception("unknown type"); + return null; + } + + JToken toJSON(ArrayValue v) { + var obj = new JObject(); + switch (v.tag) { + case ArrayValue.Tag.VBoolArray: + obj["tag"] = "VBoolArray"; + { + var tv = (data.VBoolArray)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case ArrayValue.Tag.VIntArray: + obj["tag"] = "VIntArray"; + { + var tv = (data.VIntArray)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case ArrayValue.Tag.VWordArray: + obj["tag"] = "VWordArray"; + { + var tv = (data.VWordArray)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case ArrayValue.Tag.VFloatArray: + obj["tag"] = "VFloatArray"; + { + var tv = (data.VFloatArray)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(Value v) { + var obj = new JObject(); + switch (v.tag) { + case Value.Tag.VBool: + obj["tag"] = "VBool"; + { + var tv = (data.VBool)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV2B: + obj["tag"] = "VV2B"; + { + var tv = (data.VV2B)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV3B: + obj["tag"] = "VV3B"; + { + var tv = (data.VV3B)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV4B: + obj["tag"] = "VV4B"; + { + var tv = (data.VV4B)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VWord: + obj["tag"] = "VWord"; + { + var tv = (data.VWord)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV2U: + obj["tag"] = "VV2U"; + { + var tv = (data.VV2U)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV3U: + obj["tag"] = "VV3U"; + { + var tv = (data.VV3U)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV4U: + obj["tag"] = "VV4U"; + { + var tv = (data.VV4U)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VInt: + obj["tag"] = "VInt"; + { + var tv = (data.VInt)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV2I: + obj["tag"] = "VV2I"; + { + var tv = (data.VV2I)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV3I: + obj["tag"] = "VV3I"; + { + var tv = (data.VV3I)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV4I: + obj["tag"] = "VV4I"; + { + var tv = (data.VV4I)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VFloat: + obj["tag"] = "VFloat"; + { + var tv = (data.VFloat)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV2F: + obj["tag"] = "VV2F"; + { + var tv = (data.VV2F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV3F: + obj["tag"] = "VV3F"; + { + var tv = (data.VV3F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VV4F: + obj["tag"] = "VV4F"; + { + var tv = (data.VV4F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM22F: + obj["tag"] = "VM22F"; + { + var tv = (data.VM22F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM23F: + obj["tag"] = "VM23F"; + { + var tv = (data.VM23F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM24F: + obj["tag"] = "VM24F"; + { + var tv = (data.VM24F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM32F: + obj["tag"] = "VM32F"; + { + var tv = (data.VM32F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM33F: + obj["tag"] = "VM33F"; + { + var tv = (data.VM33F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM34F: + obj["tag"] = "VM34F"; + { + var tv = (data.VM34F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM42F: + obj["tag"] = "VM42F"; + { + var tv = (data.VM42F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM43F: + obj["tag"] = "VM43F"; + { + var tv = (data.VM43F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Value.Tag.VM44F: + obj["tag"] = "VM44F"; + { + var tv = (data.VM44F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(InputType v) { + var obj = new JObject(); + switch (v.tag) { + case InputType.Tag.Bool: + obj["tag"] = "Bool"; + break; + case InputType.Tag.V2B: + obj["tag"] = "V2B"; + break; + case InputType.Tag.V3B: + obj["tag"] = "V3B"; + break; + case InputType.Tag.V4B: + obj["tag"] = "V4B"; + break; + case InputType.Tag.Word: + obj["tag"] = "Word"; + break; + case InputType.Tag.V2U: + obj["tag"] = "V2U"; + break; + case InputType.Tag.V3U: + obj["tag"] = "V3U"; + break; + case InputType.Tag.V4U: + obj["tag"] = "V4U"; + break; + case InputType.Tag.Int: + obj["tag"] = "Int"; + break; + case InputType.Tag.V2I: + obj["tag"] = "V2I"; + break; + case InputType.Tag.V3I: + obj["tag"] = "V3I"; + break; + case InputType.Tag.V4I: + obj["tag"] = "V4I"; + break; + case InputType.Tag.Float: + obj["tag"] = "Float"; + break; + case InputType.Tag.V2F: + obj["tag"] = "V2F"; + break; + case InputType.Tag.V3F: + obj["tag"] = "V3F"; + break; + case InputType.Tag.V4F: + obj["tag"] = "V4F"; + break; + case InputType.Tag.M22F: + obj["tag"] = "M22F"; + break; + case InputType.Tag.M23F: + obj["tag"] = "M23F"; + break; + case InputType.Tag.M24F: + obj["tag"] = "M24F"; + break; + case InputType.Tag.M32F: + obj["tag"] = "M32F"; + break; + case InputType.Tag.M33F: + obj["tag"] = "M33F"; + break; + case InputType.Tag.M34F: + obj["tag"] = "M34F"; + break; + case InputType.Tag.M42F: + obj["tag"] = "M42F"; + break; + case InputType.Tag.M43F: + obj["tag"] = "M43F"; + break; + case InputType.Tag.M44F: + obj["tag"] = "M44F"; + break; + case InputType.Tag.STexture1D: + obj["tag"] = "STexture1D"; + break; + case InputType.Tag.STexture2D: + obj["tag"] = "STexture2D"; + break; + case InputType.Tag.STextureCube: + obj["tag"] = "STextureCube"; + break; + case InputType.Tag.STexture1DArray: + obj["tag"] = "STexture1DArray"; + break; + case InputType.Tag.STexture2DArray: + obj["tag"] = "STexture2DArray"; + break; + case InputType.Tag.STexture2DRect: + obj["tag"] = "STexture2DRect"; + break; + case InputType.Tag.FTexture1D: + obj["tag"] = "FTexture1D"; + break; + case InputType.Tag.FTexture2D: + obj["tag"] = "FTexture2D"; + break; + case InputType.Tag.FTexture3D: + obj["tag"] = "FTexture3D"; + break; + case InputType.Tag.FTextureCube: + obj["tag"] = "FTextureCube"; + break; + case InputType.Tag.FTexture1DArray: + obj["tag"] = "FTexture1DArray"; + break; + case InputType.Tag.FTexture2DArray: + obj["tag"] = "FTexture2DArray"; + break; + case InputType.Tag.FTexture2DMS: + obj["tag"] = "FTexture2DMS"; + break; + case InputType.Tag.FTexture2DMSArray: + obj["tag"] = "FTexture2DMSArray"; + break; + case InputType.Tag.FTextureBuffer: + obj["tag"] = "FTextureBuffer"; + break; + case InputType.Tag.FTexture2DRect: + obj["tag"] = "FTexture2DRect"; + break; + case InputType.Tag.ITexture1D: + obj["tag"] = "ITexture1D"; + break; + case InputType.Tag.ITexture2D: + obj["tag"] = "ITexture2D"; + break; + case InputType.Tag.ITexture3D: + obj["tag"] = "ITexture3D"; + break; + case InputType.Tag.ITextureCube: + obj["tag"] = "ITextureCube"; + break; + case InputType.Tag.ITexture1DArray: + obj["tag"] = "ITexture1DArray"; + break; + case InputType.Tag.ITexture2DArray: + obj["tag"] = "ITexture2DArray"; + break; + case InputType.Tag.ITexture2DMS: + obj["tag"] = "ITexture2DMS"; + break; + case InputType.Tag.ITexture2DMSArray: + obj["tag"] = "ITexture2DMSArray"; + break; + case InputType.Tag.ITextureBuffer: + obj["tag"] = "ITextureBuffer"; + break; + case InputType.Tag.ITexture2DRect: + obj["tag"] = "ITexture2DRect"; + break; + case InputType.Tag.UTexture1D: + obj["tag"] = "UTexture1D"; + break; + case InputType.Tag.UTexture2D: + obj["tag"] = "UTexture2D"; + break; + case InputType.Tag.UTexture3D: + obj["tag"] = "UTexture3D"; + break; + case InputType.Tag.UTextureCube: + obj["tag"] = "UTextureCube"; + break; + case InputType.Tag.UTexture1DArray: + obj["tag"] = "UTexture1DArray"; + break; + case InputType.Tag.UTexture2DArray: + obj["tag"] = "UTexture2DArray"; + break; + case InputType.Tag.UTexture2DMS: + obj["tag"] = "UTexture2DMS"; + break; + case InputType.Tag.UTexture2DMSArray: + obj["tag"] = "UTexture2DMSArray"; + break; + case InputType.Tag.UTextureBuffer: + obj["tag"] = "UTextureBuffer"; + break; + case InputType.Tag.UTexture2DRect: + obj["tag"] = "UTexture2DRect"; + break; + } + return obj; + } + JToken toJSON(PointSpriteCoordOrigin v) { + var obj = new JObject(); + switch (v.tag) { + case PointSpriteCoordOrigin.Tag.LowerLeft: + obj["tag"] = "LowerLeft"; + break; + case PointSpriteCoordOrigin.Tag.UpperLeft: + obj["tag"] = "UpperLeft"; + break; + } + return obj; + } + JToken toJSON(PointSize v) { + var obj = new JObject(); + switch (v.tag) { + case PointSize.Tag.PointSize: + obj["tag"] = "PointSize"; + { + var tv = (data.PointSize)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case PointSize.Tag.ProgramPointSize: + obj["tag"] = "ProgramPointSize"; + break; + } + return obj; + } + JToken toJSON(PolygonOffset v) { + var obj = new JObject(); + switch (v.tag) { + case PolygonOffset.Tag.NoOffset: + obj["tag"] = "NoOffset"; + break; + case PolygonOffset.Tag.Offset: + obj["tag"] = "Offset"; + { + var tv = (data.Offset)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + } + return obj; + } + JToken toJSON(FrontFace v) { + var obj = new JObject(); + switch (v.tag) { + case FrontFace.Tag.CCW: + obj["tag"] = "CCW"; + break; + case FrontFace.Tag.CW: + obj["tag"] = "CW"; + break; + } + return obj; + } + JToken toJSON(PolygonMode v) { + var obj = new JObject(); + switch (v.tag) { + case PolygonMode.Tag.PolygonPoint: + obj["tag"] = "PolygonPoint"; + { + var tv = (data.PolygonPoint)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case PolygonMode.Tag.PolygonLine: + obj["tag"] = "PolygonLine"; + { + var tv = (data.PolygonLine)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case PolygonMode.Tag.PolygonFill: + obj["tag"] = "PolygonFill"; + break; + } + return obj; + } + JToken toJSON(ProvokingVertex v) { + var obj = new JObject(); + switch (v.tag) { + case ProvokingVertex.Tag.FirstVertex: + obj["tag"] = "FirstVertex"; + break; + case ProvokingVertex.Tag.LastVertex: + obj["tag"] = "LastVertex"; + break; + } + return obj; + } + JToken toJSON(CullMode v) { + var obj = new JObject(); + switch (v.tag) { + case CullMode.Tag.CullNone: + obj["tag"] = "CullNone"; + break; + case CullMode.Tag.CullFront: + obj["tag"] = "CullFront"; + { + var tv = (data.CullFront)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case CullMode.Tag.CullBack: + obj["tag"] = "CullBack"; + { + var tv = (data.CullBack)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(ComparisonFunction v) { + var obj = new JObject(); + switch (v.tag) { + case ComparisonFunction.Tag.Never: + obj["tag"] = "Never"; + break; + case ComparisonFunction.Tag.Less: + obj["tag"] = "Less"; + break; + case ComparisonFunction.Tag.Equal: + obj["tag"] = "Equal"; + break; + case ComparisonFunction.Tag.Lequal: + obj["tag"] = "Lequal"; + break; + case ComparisonFunction.Tag.Greater: + obj["tag"] = "Greater"; + break; + case ComparisonFunction.Tag.Notequal: + obj["tag"] = "Notequal"; + break; + case ComparisonFunction.Tag.Gequal: + obj["tag"] = "Gequal"; + break; + case ComparisonFunction.Tag.Always: + obj["tag"] = "Always"; + break; + } + return obj; + } + JToken toJSON(StencilOperation v) { + var obj = new JObject(); + switch (v.tag) { + case StencilOperation.Tag.OpZero: + obj["tag"] = "OpZero"; + break; + case StencilOperation.Tag.OpKeep: + obj["tag"] = "OpKeep"; + break; + case StencilOperation.Tag.OpReplace: + obj["tag"] = "OpReplace"; + break; + case StencilOperation.Tag.OpIncr: + obj["tag"] = "OpIncr"; + break; + case StencilOperation.Tag.OpIncrWrap: + obj["tag"] = "OpIncrWrap"; + break; + case StencilOperation.Tag.OpDecr: + obj["tag"] = "OpDecr"; + break; + case StencilOperation.Tag.OpDecrWrap: + obj["tag"] = "OpDecrWrap"; + break; + case StencilOperation.Tag.OpInvert: + obj["tag"] = "OpInvert"; + break; + } + return obj; + } + JToken toJSON(BlendEquation v) { + var obj = new JObject(); + switch (v.tag) { + case BlendEquation.Tag.FuncAdd: + obj["tag"] = "FuncAdd"; + break; + case BlendEquation.Tag.FuncSubtract: + obj["tag"] = "FuncSubtract"; + break; + case BlendEquation.Tag.FuncReverseSubtract: + obj["tag"] = "FuncReverseSubtract"; + break; + case BlendEquation.Tag.Min: + obj["tag"] = "Min"; + break; + case BlendEquation.Tag.Max: + obj["tag"] = "Max"; + break; + } + return obj; + } + JToken toJSON(BlendingFactor v) { + var obj = new JObject(); + switch (v.tag) { + case BlendingFactor.Tag.Zero: + obj["tag"] = "Zero"; + break; + case BlendingFactor.Tag.One: + obj["tag"] = "One"; + break; + case BlendingFactor.Tag.SrcColor: + obj["tag"] = "SrcColor"; + break; + case BlendingFactor.Tag.OneMinusSrcColor: + obj["tag"] = "OneMinusSrcColor"; + break; + case BlendingFactor.Tag.DstColor: + obj["tag"] = "DstColor"; + break; + case BlendingFactor.Tag.OneMinusDstColor: + obj["tag"] = "OneMinusDstColor"; + break; + case BlendingFactor.Tag.SrcAlpha: + obj["tag"] = "SrcAlpha"; + break; + case BlendingFactor.Tag.OneMinusSrcAlpha: + obj["tag"] = "OneMinusSrcAlpha"; + break; + case BlendingFactor.Tag.DstAlpha: + obj["tag"] = "DstAlpha"; + break; + case BlendingFactor.Tag.OneMinusDstAlpha: + obj["tag"] = "OneMinusDstAlpha"; + break; + case BlendingFactor.Tag.ConstantColor: + obj["tag"] = "ConstantColor"; + break; + case BlendingFactor.Tag.OneMinusConstantColor: + obj["tag"] = "OneMinusConstantColor"; + break; + case BlendingFactor.Tag.ConstantAlpha: + obj["tag"] = "ConstantAlpha"; + break; + case BlendingFactor.Tag.OneMinusConstantAlpha: + obj["tag"] = "OneMinusConstantAlpha"; + break; + case BlendingFactor.Tag.SrcAlphaSaturate: + obj["tag"] = "SrcAlphaSaturate"; + break; + } + return obj; + } + JToken toJSON(LogicOperation v) { + var obj = new JObject(); + switch (v.tag) { + case LogicOperation.Tag.Clear: + obj["tag"] = "Clear"; + break; + case LogicOperation.Tag.And: + obj["tag"] = "And"; + break; + case LogicOperation.Tag.AndReverse: + obj["tag"] = "AndReverse"; + break; + case LogicOperation.Tag.Copy: + obj["tag"] = "Copy"; + break; + case LogicOperation.Tag.AndInverted: + obj["tag"] = "AndInverted"; + break; + case LogicOperation.Tag.Noop: + obj["tag"] = "Noop"; + break; + case LogicOperation.Tag.Xor: + obj["tag"] = "Xor"; + break; + case LogicOperation.Tag.Or: + obj["tag"] = "Or"; + break; + case LogicOperation.Tag.Nor: + obj["tag"] = "Nor"; + break; + case LogicOperation.Tag.Equiv: + obj["tag"] = "Equiv"; + break; + case LogicOperation.Tag.Invert: + obj["tag"] = "Invert"; + break; + case LogicOperation.Tag.OrReverse: + obj["tag"] = "OrReverse"; + break; + case LogicOperation.Tag.CopyInverted: + obj["tag"] = "CopyInverted"; + break; + case LogicOperation.Tag.OrInverted: + obj["tag"] = "OrInverted"; + break; + case LogicOperation.Tag.Nand: + obj["tag"] = "Nand"; + break; + case LogicOperation.Tag.Set: + obj["tag"] = "Set"; + break; + } + return obj; + } + JToken toJSON(StencilOps v) { + var obj = new JObject(); + switch (v.tag) { + case StencilOps.Tag.StencilOps: + obj["tag"] = "StencilOps"; + { + var tv = (data.StencilOps)v; + obj["frontStencilOp"] = toJSON(tv.frontStencilOp); + obj["backStencilOp"] = toJSON(tv.backStencilOp); + } + break; + } + return obj; + } + JToken toJSON(StencilTest v) { + var obj = new JObject(); + switch (v.tag) { + case StencilTest.Tag.StencilTest: + obj["tag"] = "StencilTest"; + { + var tv = (data.StencilTest)v; + obj["stencilComparision"] = toJSON(tv.stencilComparision); + obj["stencilReference"] = toJSON(tv.stencilReference); + obj["stencilMask"] = toJSON(tv.stencilMask); + } + break; + } + return obj; + } + JToken toJSON(StencilTests v) { + var obj = new JObject(); + switch (v.tag) { + case StencilTests.Tag.StencilTests: + obj["tag"] = "StencilTests"; + { + var tv = (data.StencilTests)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + } + return obj; + } + JToken toJSON(FetchPrimitive v) { + var obj = new JObject(); + switch (v.tag) { + case FetchPrimitive.Tag.Points: + obj["tag"] = "Points"; + break; + case FetchPrimitive.Tag.Lines: + obj["tag"] = "Lines"; + break; + case FetchPrimitive.Tag.Triangles: + obj["tag"] = "Triangles"; + break; + case FetchPrimitive.Tag.LinesAdjacency: + obj["tag"] = "LinesAdjacency"; + break; + case FetchPrimitive.Tag.TrianglesAdjacency: + obj["tag"] = "TrianglesAdjacency"; + break; + } + return obj; + } + JToken toJSON(OutputPrimitive v) { + var obj = new JObject(); + switch (v.tag) { + case OutputPrimitive.Tag.TrianglesOutput: + obj["tag"] = "TrianglesOutput"; + break; + case OutputPrimitive.Tag.LinesOutput: + obj["tag"] = "LinesOutput"; + break; + case OutputPrimitive.Tag.PointsOutput: + obj["tag"] = "PointsOutput"; + break; + } + return obj; + } + JToken toJSON(ColorArity v) { + var obj = new JObject(); + switch (v.tag) { + case ColorArity.Tag.Red: + obj["tag"] = "Red"; + break; + case ColorArity.Tag.RG: + obj["tag"] = "RG"; + break; + case ColorArity.Tag.RGB: + obj["tag"] = "RGB"; + break; + case ColorArity.Tag.RGBA: + obj["tag"] = "RGBA"; + break; + } + return obj; + } + JToken toJSON(Blending v) { + var obj = new JObject(); + switch (v.tag) { + case Blending.Tag.NoBlending: + obj["tag"] = "NoBlending"; + break; + case Blending.Tag.BlendLogicOp: + obj["tag"] = "BlendLogicOp"; + { + var tv = (data.BlendLogicOp)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Blending.Tag.Blend: + obj["tag"] = "Blend"; + { + var tv = (data.Blend)v; + obj["colorEqSrc"] = toJSON(tv.colorEqSrc); + obj["alphaEqSrc"] = toJSON(tv.alphaEqSrc); + obj["colorFSrc"] = toJSON(tv.colorFSrc); + obj["colorFDst"] = toJSON(tv.colorFDst); + obj["alphaFSrc"] = toJSON(tv.alphaFSrc); + obj["alphaFDst"] = toJSON(tv.alphaFDst); + obj["color"] = toJSON(tv.color); + } + break; + } + return obj; + } + JToken toJSON(RasterContext v) { + var obj = new JObject(); + switch (v.tag) { + case RasterContext.Tag.PointCtx: + obj["tag"] = "PointCtx"; + { + var tv = (data.PointCtx)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + } + break; + case RasterContext.Tag.LineCtx: + obj["tag"] = "LineCtx"; + { + var tv = (data.LineCtx)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case RasterContext.Tag.TriangleCtx: + obj["tag"] = "TriangleCtx"; + { + var tv = (data.TriangleCtx)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + obj["arg3"] = toJSON(tv._3); + } + break; + } + return obj; + } + JToken toJSON(FragmentOperation v) { + var obj = new JObject(); + switch (v.tag) { + case FragmentOperation.Tag.DepthOp: + obj["tag"] = "DepthOp"; + { + var tv = (data.DepthOp)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case FragmentOperation.Tag.StencilOp: + obj["tag"] = "StencilOp"; + { + var tv = (data.StencilOp)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + } + break; + case FragmentOperation.Tag.ColorOp: + obj["tag"] = "ColorOp"; + { + var tv = (data.ColorOp)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + } + return obj; + } + JToken toJSON(AccumulationContext v) { + var obj = new JObject(); + switch (v.tag) { + case AccumulationContext.Tag.AccumulationContext: + obj["tag"] = "AccumulationContext"; + { + var tv = (data.AccumulationContext)v; + obj["accViewportName"] = toJSON(tv.accViewportName); + obj["accOperations"] = toJSON(tv.accOperations); + } + break; + } + return obj; + } + JToken toJSON(TextureDataType v) { + var obj = new JObject(); + switch (v.tag) { + case TextureDataType.Tag.FloatT: + obj["tag"] = "FloatT"; + { + var tv = (data.FloatT)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case TextureDataType.Tag.IntT: + obj["tag"] = "IntT"; + { + var tv = (data.IntT)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case TextureDataType.Tag.WordT: + obj["tag"] = "WordT"; + { + var tv = (data.WordT)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case TextureDataType.Tag.ShadowT: + obj["tag"] = "ShadowT"; + break; + } + return obj; + } + JToken toJSON(TextureType v) { + var obj = new JObject(); + switch (v.tag) { + case TextureType.Tag.Texture1D: + obj["tag"] = "Texture1D"; + { + var tv = (data.Texture1D)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case TextureType.Tag.Texture2D: + obj["tag"] = "Texture2D"; + { + var tv = (data.Texture2D)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case TextureType.Tag.Texture3D: + obj["tag"] = "Texture3D"; + { + var tv = (data.Texture3D)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case TextureType.Tag.TextureCube: + obj["tag"] = "TextureCube"; + { + var tv = (data.TextureCube)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case TextureType.Tag.TextureRect: + obj["tag"] = "TextureRect"; + { + var tv = (data.TextureRect)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case TextureType.Tag.Texture2DMS: + obj["tag"] = "Texture2DMS"; + { + var tv = (data.Texture2DMS)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + obj["arg3"] = toJSON(tv._3); + } + break; + case TextureType.Tag.TextureBuffer: + obj["tag"] = "TextureBuffer"; + { + var tv = (data.TextureBuffer)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(MipMap v) { + var obj = new JObject(); + switch (v.tag) { + case MipMap.Tag.Mip: + obj["tag"] = "Mip"; + { + var tv = (data.Mip)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case MipMap.Tag.NoMip: + obj["tag"] = "NoMip"; + break; + case MipMap.Tag.AutoMip: + obj["tag"] = "AutoMip"; + { + var tv = (data.AutoMip)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + } + return obj; + } + JToken toJSON(Filter v) { + var obj = new JObject(); + switch (v.tag) { + case Filter.Tag.Nearest: + obj["tag"] = "Nearest"; + break; + case Filter.Tag.Linear: + obj["tag"] = "Linear"; + break; + case Filter.Tag.NearestMipmapNearest: + obj["tag"] = "NearestMipmapNearest"; + break; + case Filter.Tag.NearestMipmapLinear: + obj["tag"] = "NearestMipmapLinear"; + break; + case Filter.Tag.LinearMipmapNearest: + obj["tag"] = "LinearMipmapNearest"; + break; + case Filter.Tag.LinearMipmapLinear: + obj["tag"] = "LinearMipmapLinear"; + break; + } + return obj; + } + JToken toJSON(EdgeMode v) { + var obj = new JObject(); + switch (v.tag) { + case EdgeMode.Tag.Repeat: + obj["tag"] = "Repeat"; + break; + case EdgeMode.Tag.MirroredRepeat: + obj["tag"] = "MirroredRepeat"; + break; + case EdgeMode.Tag.ClampToEdge: + obj["tag"] = "ClampToEdge"; + break; + case EdgeMode.Tag.ClampToBorder: + obj["tag"] = "ClampToBorder"; + break; + } + return obj; + } + JToken toJSON(ImageSemantic v) { + var obj = new JObject(); + switch (v.tag) { + case ImageSemantic.Tag.Depth: + obj["tag"] = "Depth"; + break; + case ImageSemantic.Tag.Stencil: + obj["tag"] = "Stencil"; + break; + case ImageSemantic.Tag.Color: + obj["tag"] = "Color"; + break; + } + return obj; + } + JToken toJSON(ImageRef v) { + var obj = new JObject(); + switch (v.tag) { + case ImageRef.Tag.TextureImage: + obj["tag"] = "TextureImage"; + { + var tv = (data.TextureImage)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + } + break; + case ImageRef.Tag.Framebuffer: + obj["tag"] = "Framebuffer"; + { + var tv = (data.Framebuffer)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(ClearImage v) { + var obj = new JObject(); + switch (v.tag) { + case ClearImage.Tag.ClearImage: + obj["tag"] = "ClearImage"; + { + var tv = (data.ClearImage)v; + obj["imageSemantic"] = toJSON(tv.imageSemantic); + obj["clearValue"] = toJSON(tv.clearValue); + } + break; + } + return obj; + } + JToken toJSON(Command v) { + var obj = new JObject(); + switch (v.tag) { + case Command.Tag.SetRasterContext: + obj["tag"] = "SetRasterContext"; + { + var tv = (data.SetRasterContext)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.SetAccumulationContext: + obj["tag"] = "SetAccumulationContext"; + { + var tv = (data.SetAccumulationContext)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.SetRenderTarget: + obj["tag"] = "SetRenderTarget"; + { + var tv = (data.SetRenderTarget)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.SetProgram: + obj["tag"] = "SetProgram"; + { + var tv = (data.SetProgram)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.SetSamplerUniform: + obj["tag"] = "SetSamplerUniform"; + { + var tv = (data.SetSamplerUniform)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case Command.Tag.SetTexture: + obj["tag"] = "SetTexture"; + { + var tv = (data.SetTexture)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case Command.Tag.SetSampler: + obj["tag"] = "SetSampler"; + { + var tv = (data.SetSampler)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case Command.Tag.RenderSlot: + obj["tag"] = "RenderSlot"; + { + var tv = (data.RenderSlot)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.RenderStream: + obj["tag"] = "RenderStream"; + { + var tv = (data.RenderStream)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.ClearRenderTarget: + obj["tag"] = "ClearRenderTarget"; + { + var tv = (data.ClearRenderTarget)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.GenerateMipMap: + obj["tag"] = "GenerateMipMap"; + { + var tv = (data.GenerateMipMap)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case Command.Tag.SaveImage: + obj["tag"] = "SaveImage"; + { + var tv = (data.SaveImage)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + case Command.Tag.LoadImage: + obj["tag"] = "LoadImage"; + { + var tv = (data.LoadImage)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + } + break; + } + return obj; + } + JToken toJSON(SamplerDescriptor v) { + var obj = new JObject(); + switch (v.tag) { + case SamplerDescriptor.Tag.SamplerDescriptor: + obj["tag"] = "SamplerDescriptor"; + { + var tv = (data.SamplerDescriptor)v; + obj["samplerWrapS"] = toJSON(tv.samplerWrapS); + obj["samplerWrapT"] = toJSON(tv.samplerWrapT); + obj["samplerWrapR"] = toJSON(tv.samplerWrapR); + obj["samplerMinFilter"] = toJSON(tv.samplerMinFilter); + obj["samplerMagFilter"] = toJSON(tv.samplerMagFilter); + obj["samplerBorderColor"] = toJSON(tv.samplerBorderColor); + obj["samplerMinLod"] = toJSON(tv.samplerMinLod); + obj["samplerMaxLod"] = toJSON(tv.samplerMaxLod); + obj["samplerLodBias"] = toJSON(tv.samplerLodBias); + obj["samplerCompareFunc"] = toJSON(tv.samplerCompareFunc); + } + break; + } + return obj; + } + JToken toJSON(TextureDescriptor v) { + var obj = new JObject(); + switch (v.tag) { + case TextureDescriptor.Tag.TextureDescriptor: + obj["tag"] = "TextureDescriptor"; + { + var tv = (data.TextureDescriptor)v; + obj["textureType"] = toJSON(tv.textureType); + obj["textureSize"] = toJSON(tv.textureSize); + obj["textureSemantic"] = toJSON(tv.textureSemantic); + obj["textureSampler"] = toJSON(tv.textureSampler); + obj["textureBaseLevel"] = toJSON(tv.textureBaseLevel); + obj["textureMaxLevel"] = toJSON(tv.textureMaxLevel); + } + break; + } + return obj; + } + JToken toJSON(Parameter v) { + var obj = new JObject(); + switch (v.tag) { + case Parameter.Tag.Parameter: + obj["tag"] = "Parameter"; + { + var tv = (data.Parameter)v; + obj["name"] = toJSON(tv.name); + obj["ty"] = toJSON(tv.ty); + } + break; + } + return obj; + } + JToken toJSON(Program v) { + var obj = new JObject(); + switch (v.tag) { + case Program.Tag.Program: + obj["tag"] = "Program"; + { + var tv = (data.Program)v; + obj["programUniforms"] = toJSON(tv.programUniforms); + obj["programStreams"] = toJSON(tv.programStreams); + obj["programInTextures"] = toJSON(tv.programInTextures); + obj["programOutput"] = toJSON(tv.programOutput); + obj["vertexShader"] = toJSON(tv.vertexShader); + obj["geometryShader"] = toJSON(tv.geometryShader); + obj["fragmentShader"] = toJSON(tv.fragmentShader); + } + break; + } + return obj; + } + JToken toJSON(Slot v) { + var obj = new JObject(); + switch (v.tag) { + case Slot.Tag.Slot: + obj["tag"] = "Slot"; + { + var tv = (data.Slot)v; + obj["slotName"] = toJSON(tv.slotName); + obj["slotStreams"] = toJSON(tv.slotStreams); + obj["slotUniforms"] = toJSON(tv.slotUniforms); + obj["slotPrimitive"] = toJSON(tv.slotPrimitive); + obj["slotPrograms"] = toJSON(tv.slotPrograms); + } + break; + } + return obj; + } + JToken toJSON(StreamData v) { + var obj = new JObject(); + switch (v.tag) { + case StreamData.Tag.StreamData: + obj["tag"] = "StreamData"; + { + var tv = (data.StreamData)v; + obj["streamData"] = toJSON(tv.streamData); + obj["streamType"] = toJSON(tv.streamType); + obj["streamPrimitive"] = toJSON(tv.streamPrimitive); + obj["streamPrograms"] = toJSON(tv.streamPrograms); + } + break; + } + return obj; + } + JToken toJSON(TargetItem v) { + var obj = new JObject(); + switch (v.tag) { + case TargetItem.Tag.TargetItem: + obj["tag"] = "TargetItem"; + { + var tv = (data.TargetItem)v; + obj["targetSemantic"] = toJSON(tv.targetSemantic); + obj["targetRef"] = toJSON(tv.targetRef); + } + break; + } + return obj; + } + JToken toJSON(RenderTarget v) { + var obj = new JObject(); + switch (v.tag) { + case RenderTarget.Tag.RenderTarget: + obj["tag"] = "RenderTarget"; + { + var tv = (data.RenderTarget)v; + obj["renderTargets"] = toJSON(tv.renderTargets); + } + break; + } + return obj; + } + JToken toJSON(Backend v) { + var obj = new JObject(); + switch (v.tag) { + case Backend.Tag.WebGL1: + obj["tag"] = "WebGL1"; + break; + case Backend.Tag.OpenGL33: + obj["tag"] = "OpenGL33"; + break; + } + return obj; + } + JToken toJSON(Pipeline v) { + var obj = new JObject(); + switch (v.tag) { + case Pipeline.Tag.Pipeline: + obj["tag"] = "Pipeline"; + { + var tv = (data.Pipeline)v; + obj["info"] = toJSON(tv.info); + obj["backend"] = toJSON(tv.backend); + obj["textures"] = toJSON(tv.textures); + obj["samplers"] = toJSON(tv.samplers); + obj["targets"] = toJSON(tv.targets); + obj["programs"] = toJSON(tv.programs); + obj["slots"] = toJSON(tv.slots); + obj["streams"] = toJSON(tv.streams); + obj["commands"] = toJSON(tv.commands); + } + break; + } + return obj; + } + + JToken toJSON(int v) { return new JValue(v); } + JToken toJSON(uint v) { return new JValue(v); } + JToken toJSON(float v) { return new JValue(v); } + JToken toJSON(bool v) { return new JValue(v); } + JToken toJSON(string v) { return new JValue(v); } + JToken toJSON(V2 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V3 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V4 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(Maybe v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + JToken toJSON(Maybe v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + JToken toJSON(Maybe v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + JToken toJSON(Maybe v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + JToken toJSON(Maybe v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + JToken toJSON(Maybe v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + } +} diff --git a/ddl/out/LambdaCube.IR.hpp b/ddl/out/LambdaCube.IR.hpp index 0e139b1..d6d74ac 100644 --- a/ddl/out/LambdaCube.IR.hpp +++ b/ddl/out/LambdaCube.IR.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.426854000000Z +======= +// 2016-03-20T21:42:12.172652000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.IR_H #define HEADER_LambdaCube.IR_H diff --git a/ddl/out/LambdaCube.IR.hs b/ddl/out/LambdaCube.IR.hs index 7776a6d..2a414dc 100644 --- a/ddl/out/LambdaCube.IR.hs +++ b/ddl/out/LambdaCube.IR.hs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.426854000000Z +======= +-- 2016-03-20T21:42:12.172652000000Z +>>>>>>> working c# backend {-# LANGUAGE OverloadedStrings, RecordWildCards #-} module LambdaCube.IR where diff --git a/ddl/out/LambdaCube.IR.java b/ddl/out/LambdaCube.IR.java new file mode 100644 index 0000000..b819bcb --- /dev/null +++ b/ddl/out/LambdaCube.IR.java @@ -0,0 +1,877 @@ +// generated file, do not modify! +// 2016-03-14T10:58:29.577511000000Z + + +public class LambdaCube.IR { + public class ArrayValue { + public enum Tag { + VBoolArray, + VIntArray, + VWordArray, + VFloatArray + } + public Tag tag; + + public class VBoolArray extends ArrayValue { + public ArrayList _0; + } + public class VIntArray extends ArrayValue { + public ArrayList _0; + } + public class VWordArray extends ArrayValue { + public ArrayList _0; + } + public class VFloatArray extends ArrayValue { + public ArrayList _0; + } + } + + public class Value { + public enum 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 + } + public Tag tag; + + public class VBool extends Value { + public Boolean _0; + } + public class VV2B extends Value { + public int _0; + } + public class VV3B extends Value { + public int _0; + } + public class VV4B extends Value { + public int _0; + } + public class VWord extends Value { + public Integer _0; + } + public class VV2U extends Value { + public int _0; + } + public class VV3U extends Value { + public int _0; + } + public class VV4U extends Value { + public int _0; + } + public class VInt extends Value { + public Integer _0; + } + public class VV2I extends Value { + public int _0; + } + public class VV3I extends Value { + public int _0; + } + public class VV4I extends Value { + public int _0; + } + public class VFloat extends Value { + public Float _0; + } + public class VV2F extends Value { + public int _0; + } + public class VV3F extends Value { + public int _0; + } + public class VV4F extends Value { + public int _0; + } + public class VM22F extends Value { + public int _0; + } + public class VM23F extends Value { + public int _0; + } + public class VM24F extends Value { + public int _0; + } + public class VM32F extends Value { + public int _0; + } + public class VM33F extends Value { + public int _0; + } + public class VM34F extends Value { + public int _0; + } + public class VM42F extends Value { + public int _0; + } + public class VM43F extends Value { + public int _0; + } + public class VM44F extends Value { + public int _0; + } + } + + public class InputType { + public enum 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 + } + public Tag tag; + + } + + public class PointSpriteCoordOrigin { + public enum Tag { + LowerLeft, + UpperLeft + } + public Tag tag; + + } + + public class PointSize { + public enum Tag { + PointSize, + ProgramPointSize + } + public Tag tag; + + public class PointSize extends PointSize { + public Float _0; + } + } + + public class PolygonOffset { + public enum Tag { + NoOffset, + Offset + } + public Tag tag; + + public class Offset extends PolygonOffset { + public Float _0; + public Float _1; + } + } + + public class FrontFace { + public enum Tag { + CCW, + CW + } + public Tag tag; + + } + + public class PolygonMode { + public enum Tag { + PolygonPoint, + PolygonLine, + PolygonFill + } + public Tag tag; + + public class PolygonPoint extends PolygonMode { + public PointSize _0; + } + public class PolygonLine extends PolygonMode { + public Float _0; + } + } + + public class ProvokingVertex { + public enum Tag { + FirstVertex, + LastVertex + } + public Tag tag; + + } + + public class CullMode { + public enum Tag { + CullNone, + CullFront, + CullBack + } + public Tag tag; + + public class CullFront extends CullMode { + public FrontFace _0; + } + public class CullBack extends CullMode { + public FrontFace _0; + } + } + + public class ComparisonFunction { + public enum Tag { + Never, + Less, + Equal, + Lequal, + Greater, + Notequal, + Gequal, + Always + } + public Tag tag; + + } + + public class StencilOperation { + public enum Tag { + OpZero, + OpKeep, + OpReplace, + OpIncr, + OpIncrWrap, + OpDecr, + OpDecrWrap, + OpInvert + } + public Tag tag; + + } + + public class BlendEquation { + public enum Tag { + FuncAdd, + FuncSubtract, + FuncReverseSubtract, + Min, + Max + } + public Tag tag; + + } + + public class BlendingFactor { + public enum Tag { + Zero, + One, + SrcColor, + OneMinusSrcColor, + DstColor, + OneMinusDstColor, + SrcAlpha, + OneMinusSrcAlpha, + DstAlpha, + OneMinusDstAlpha, + ConstantColor, + OneMinusConstantColor, + ConstantAlpha, + OneMinusConstantAlpha, + SrcAlphaSaturate + } + public Tag tag; + + } + + public class LogicOperation { + public enum Tag { + Clear, + And, + AndReverse, + Copy, + AndInverted, + Noop, + Xor, + Or, + Nor, + Equiv, + Invert, + OrReverse, + CopyInverted, + OrInverted, + Nand, + Set + } + public Tag tag; + + } + + public class StencilOps { + public enum Tag { + StencilOps + } + public Tag tag; + + public class StencilOps extends StencilOps { + public StencilOperation frontStencilOp; + public StencilOperation backStencilOp; + } + } + + public class StencilTest { + public enum Tag { + StencilTest + } + public Tag tag; + + public class StencilTest extends StencilTest { + public ComparisonFunction stencilComparision; + public Integer stencilReference; + public Integer stencilMask; + } + } + + public class StencilTests { + public enum Tag { + StencilTests + } + public Tag tag; + + public class StencilTests extends StencilTests { + public StencilTest _0; + public StencilTest _1; + } + } + + public class FetchPrimitive { + public enum Tag { + Points, + Lines, + Triangles, + LinesAdjacency, + TrianglesAdjacency + } + public Tag tag; + + } + + public class OutputPrimitive { + public enum Tag { + TrianglesOutput, + LinesOutput, + PointsOutput + } + public Tag tag; + + } + + public class ColorArity { + public enum Tag { + Red, + RG, + RGB, + RGBA + } + public Tag tag; + + } + + public class Blending { + public enum Tag { + NoBlending, + BlendLogicOp, + Blend + } + public Tag tag; + + public class BlendLogicOp extends Blending { + public LogicOperation _0; + } + public class Blend extends Blending { + public BlendEquation colorEqSrc; + public BlendEquation alphaEqSrc; + public BlendingFactor colorFSrc; + public BlendingFactor colorFDst; + public BlendingFactor alphaFSrc; + public BlendingFactor alphaFDst; + public int color; + } + } + + public class RasterContext { + public enum Tag { + PointCtx, + LineCtx, + TriangleCtx + } + public Tag tag; + + public class PointCtx extends RasterContext { + public PointSize _0; + public Float _1; + public PointSpriteCoordOrigin _2; + } + public class LineCtx extends RasterContext { + public Float _0; + public ProvokingVertex _1; + } + public class TriangleCtx extends RasterContext { + public CullMode _0; + public PolygonMode _1; + public PolygonOffset _2; + public ProvokingVertex _3; + } + } + + public class FragmentOperation { + public enum Tag { + DepthOp, + StencilOp, + ColorOp + } + public Tag tag; + + public class DepthOp extends FragmentOperation { + public ComparisonFunction _0; + public Boolean _1; + } + public class StencilOp extends FragmentOperation { + public StencilTests _0; + public StencilOps _1; + public StencilOps _2; + } + public class ColorOp extends FragmentOperation { + public Blending _0; + public Value _1; + } + } + + public class AccumulationContext { + public enum Tag { + AccumulationContext + } + public Tag tag; + + public class AccumulationContext extends AccumulationContext { + public int accViewportName; + public ArrayList accOperations; + } + } + + public class TextureDataType { + public enum Tag { + FloatT, + IntT, + WordT, + ShadowT + } + public Tag tag; + + public class FloatT extends TextureDataType { + public ColorArity _0; + } + public class IntT extends TextureDataType { + public ColorArity _0; + } + public class WordT extends TextureDataType { + public ColorArity _0; + } + } + + public class TextureType { + public enum Tag { + Texture1D, + Texture2D, + Texture3D, + TextureCube, + TextureRect, + Texture2DMS, + TextureBuffer + } + public Tag tag; + + public class Texture1D extends TextureType { + public TextureDataType _0; + public Integer _1; + } + public class Texture2D extends TextureType { + public TextureDataType _0; + public Integer _1; + } + public class Texture3D extends TextureType { + public TextureDataType _0; + } + public class TextureCube extends TextureType { + public TextureDataType _0; + } + public class TextureRect extends TextureType { + public TextureDataType _0; + } + public class Texture2DMS extends TextureType { + public TextureDataType _0; + public Integer _1; + public Integer _2; + public Boolean _3; + } + public class TextureBuffer extends TextureType { + public TextureDataType _0; + } + } + + public class MipMap { + public enum Tag { + Mip, + NoMip, + AutoMip + } + public Tag tag; + + public class Mip extends MipMap { + public Integer _0; + public Integer _1; + } + public class AutoMip extends MipMap { + public Integer _0; + public Integer _1; + } + } + + public class Filter { + public enum Tag { + Nearest, + Linear, + NearestMipmapNearest, + NearestMipmapLinear, + LinearMipmapNearest, + LinearMipmapLinear + } + public Tag tag; + + } + + public class EdgeMode { + public enum Tag { + Repeat, + MirroredRepeat, + ClampToEdge, + ClampToBorder + } + public Tag tag; + + } + + public class ImageSemantic { + public enum Tag { + Depth, + Stencil, + Color + } + public Tag tag; + + } + + public class ImageRef { + public enum Tag { + TextureImage, + Framebuffer + } + public Tag tag; + + public class TextureImage extends ImageRef { + public Integer _0; + public Integer _1; + public int _2; + } + public class Framebuffer extends ImageRef { + public ImageSemantic _0; + } + } + + public class ClearImage { + public enum Tag { + ClearImage + } + public Tag tag; + + public class ClearImage extends ClearImage { + public ImageSemantic imageSemantic; + public Value clearValue; + } + } + + public class Command { + public enum Tag { + SetRasterContext, + SetAccumulationContext, + SetRenderTarget, + SetProgram, + SetSamplerUniform, + SetTexture, + SetSampler, + RenderSlot, + RenderStream, + ClearRenderTarget, + GenerateMipMap, + SaveImage, + LoadImage + } + public Tag tag; + + public class SetRasterContext extends Command { + public RasterContext _0; + } + public class SetAccumulationContext extends Command { + public AccumulationContext _0; + } + public class SetRenderTarget extends Command { + public Integer _0; + } + public class SetProgram extends Command { + public Integer _0; + } + public class SetSamplerUniform extends Command { + public String _0; + public Integer _1; + } + public class SetTexture extends Command { + public Integer _0; + public Integer _1; + } + public class SetSampler extends Command { + public Integer _0; + public int _1; + } + public class RenderSlot extends Command { + public Integer _0; + } + public class RenderStream extends Command { + public Integer _0; + } + public class ClearRenderTarget extends Command { + public ArrayList _0; + } + public class GenerateMipMap extends Command { + public Integer _0; + } + public class SaveImage extends Command { + public Integer _0; + public ImageRef _1; + } + public class LoadImage extends Command { + public ImageRef _0; + public Integer _1; + } + } + + public class SamplerDescriptor { + public enum Tag { + SamplerDescriptor + } + public Tag tag; + + public class SamplerDescriptor extends SamplerDescriptor { + public EdgeMode samplerWrapS; + public int samplerWrapT; + public int samplerWrapR; + public Filter samplerMinFilter; + public Filter samplerMagFilter; + public Value samplerBorderColor; + public int samplerMinLod; + public int samplerMaxLod; + public Float samplerLodBias; + public int samplerCompareFunc; + } + } + + public class TextureDescriptor { + public enum Tag { + TextureDescriptor + } + public Tag tag; + + public class TextureDescriptor extends TextureDescriptor { + public TextureType textureType; + public Value textureSize; + public ImageSemantic textureSemantic; + public SamplerDescriptor textureSampler; + public Integer textureBaseLevel; + public Integer textureMaxLevel; + } + } + + public class Parameter { + public enum Tag { + Parameter + } + public Tag tag; + + public class Parameter extends Parameter { + public String name; + public InputType ty; + } + } + + public class Program { + public enum Tag { + Program + } + public Tag tag; + + public class Program extends Program { + public HashMap programUniforms; + public HashMap programStreams; + public HashMap programInTextures; + public ArrayList programOutput; + public String vertexShader; + public int geometryShader; + public String fragmentShader; + } + } + + public class Slot { + public enum Tag { + Slot + } + public Tag tag; + + public class Slot extends Slot { + public String slotName; + public HashMap slotStreams; + public HashMap slotUniforms; + public FetchPrimitive slotPrimitive; + public ArrayList slotPrograms; + } + } + + public class StreamData { + public enum Tag { + StreamData + } + public Tag tag; + + public class StreamData extends StreamData { + public HashMap streamData; + public HashMap streamType; + public FetchPrimitive streamPrimitive; + public ArrayList streamPrograms; + } + } + + public class TargetItem { + public enum Tag { + TargetItem + } + public Tag tag; + + public class TargetItem extends TargetItem { + public ImageSemantic targetSemantic; + public int targetRef; + } + } + + public class RenderTarget { + public enum Tag { + RenderTarget + } + public Tag tag; + + public class RenderTarget extends RenderTarget { + public ArrayList renderTargets; + } + } + + public class Backend { + public enum Tag { + WebGL1, + OpenGL33 + } + public Tag tag; + + } + + public class Pipeline { + public enum Tag { + Pipeline + } + public Tag tag; + + public class Pipeline extends Pipeline { + public String info; + public Backend backend; + public ArrayList textures; + public ArrayList samplers; + public ArrayList targets; + public ArrayList programs; + public ArrayList slots; + public ArrayList streams; + public ArrayList commands; + } + } + +} \ No newline at end of file diff --git a/ddl/out/LambdaCube.IR.purs b/ddl/out/LambdaCube.IR.purs index 5e2e548..7a36d7e 100644 --- a/ddl/out/LambdaCube.IR.purs +++ b/ddl/out/LambdaCube.IR.purs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.426854000000Z +======= +-- 2016-03-20T21:42:12.172652000000Z +>>>>>>> working c# backend module LambdaCube.IR where import Prelude diff --git a/ddl/out/LambdaCube.IR.swift b/ddl/out/LambdaCube.IR.swift index 3131320..4cc6239 100644 --- a/ddl/out/LambdaCube.IR.swift +++ b/ddl/out/LambdaCube.IR.swift @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.426854000000Z +======= +// 2016-03-20T21:42:12.172652000000Z +>>>>>>> working c# backend typealias StreamName = Int diff --git a/ddl/out/LambdaCube.IR2.hpp b/ddl/out/LambdaCube.IR2.hpp index 48153e5..a2e531a 100644 --- a/ddl/out/LambdaCube.IR2.hpp +++ b/ddl/out/LambdaCube.IR2.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.426854000000Z +======= +// 2016-03-20T21:42:12.172652000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.IR_H #define HEADER_LambdaCube.IR_H diff --git a/ddl/out/LambdaCube.Mesh.cpp b/ddl/out/LambdaCube.Mesh.cpp index ccbf035..aa1ca00 100644 --- a/ddl/out/LambdaCube.Mesh.cpp +++ b/ddl/out/LambdaCube.Mesh.cpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.781208000000Z +======= +// 2016-03-20T21:42:12.936741000000Z +>>>>>>> working c# backend #include "LambdaCube.Mesh.hpp" template<> json toJSON>(std::shared_ptr &v) { diff --git a/ddl/out/LambdaCube.Mesh.cs b/ddl/out/LambdaCube.Mesh.cs new file mode 100644 index 0000000..62b8d29 --- /dev/null +++ b/ddl/out/LambdaCube.Mesh.cs @@ -0,0 +1,529 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.391032000000Z + +using System; +using System.Linq; +using System.Collections.Generic; +using Newtonsoft.Json.Linq; + + +namespace LambdaCube.Mesh { + class MeshAttribute { + public enum Tag { + A_Float, + A_V2F, + A_V3F, + A_V4F, + A_M22F, + A_M33F, + A_M44F, + A_Int, + A_Word + }; + public Tag tag; + }; + + namespace data { + class A_Float : LambdaCube.Mesh.MeshAttribute { + public List _0; + public A_Float() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_Float; } + }; + class A_V2F : LambdaCube.Mesh.MeshAttribute { + public List> _0; + public A_V2F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_V2F; } + }; + class A_V3F : LambdaCube.Mesh.MeshAttribute { + public List> _0; + public A_V3F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_V3F; } + }; + class A_V4F : LambdaCube.Mesh.MeshAttribute { + public List> _0; + public A_V4F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_V4F; } + }; + class A_M22F : LambdaCube.Mesh.MeshAttribute { + public List>> _0; + public A_M22F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_M22F; } + }; + class A_M33F : LambdaCube.Mesh.MeshAttribute { + public List>> _0; + public A_M33F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_M33F; } + }; + class A_M44F : LambdaCube.Mesh.MeshAttribute { + public List>> _0; + public A_M44F() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_M44F; } + }; + class A_Int : LambdaCube.Mesh.MeshAttribute { + public List _0; + public A_Int() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_Int; } + }; + class A_Word : LambdaCube.Mesh.MeshAttribute { + public List _0; + public A_Word() { tag = LambdaCube.Mesh.MeshAttribute.Tag.A_Word; } + }; + } + class MeshPrimitive { + public enum Tag { + P_Points, + P_TriangleStrip, + P_Triangles, + P_TriangleStripI, + P_TrianglesI + }; + public Tag tag; + }; + + namespace data { + class P_TriangleStripI : LambdaCube.Mesh.MeshPrimitive { + public List _0; + public P_TriangleStripI() { tag = LambdaCube.Mesh.MeshPrimitive.Tag.P_TriangleStripI; } + }; + class P_TrianglesI : LambdaCube.Mesh.MeshPrimitive { + public List _0; + public P_TrianglesI() { tag = LambdaCube.Mesh.MeshPrimitive.Tag.P_TrianglesI; } + }; + } + class Mesh { + public enum Tag { + Mesh + }; + public Tag tag; + }; + + namespace data { + class Mesh : LambdaCube.Mesh.Mesh { + public Dictionary mAttributes; + public global::LambdaCube.Mesh.MeshPrimitive mPrimitive; + public Mesh() { tag = LambdaCube.Mesh.Mesh.Tag.Mesh; } + }; + } + + // JSON deserializer + enum Type { + Int32, + Word32, + Float, + String, + V2_Float, + V2_V2_Float, + V3_Float, + V3_V3_Float, + V4_Float, + V4_V4_Float, + Array_Int32, + Array_Word32, + Array_Float, + Array_V2_Float, + Array_V2_V2_Float, + Array_V3_Float, + Array_V3_V3_Float, + Array_V4_Float, + Array_V4_V4_Float, + Map_String_MeshAttribute, + Mesh, + MeshAttribute, + MeshPrimitive + } + + class Loader { + public static object fromJSON(Type type, JToken obj) { + switch (type) { + case Type.Int32: return (int)obj; + case Type.Word32: return (uint)obj; + case Type.Float: return (float)obj; + case Type.String: return (string)obj; + case Type.V2_Float: + return new V2 + { x = (float)fromJSON(Type.Float,obj["x"]) + , y = (float)fromJSON(Type.Float,obj["y"]) + }; + case Type.V2_V2_Float: + return new V2> + { x = (V2)fromJSON(Type.V2_Float,obj["x"]) + , y = (V2)fromJSON(Type.V2_Float,obj["y"]) + }; + case Type.V3_Float: + return new V3 + { x = (float)fromJSON(Type.Float,obj["x"]) + , y = (float)fromJSON(Type.Float,obj["y"]) + , z = (float)fromJSON(Type.Float,obj["z"]) + }; + case Type.V3_V3_Float: + return new V3> + { x = (V3)fromJSON(Type.V3_Float,obj["x"]) + , y = (V3)fromJSON(Type.V3_Float,obj["y"]) + , z = (V3)fromJSON(Type.V3_Float,obj["z"]) + }; + case Type.V4_Float: + return new V4 + { x = (float)fromJSON(Type.Float,obj["x"]) + , y = (float)fromJSON(Type.Float,obj["y"]) + , z = (float)fromJSON(Type.Float,obj["z"]) + , w = (float)fromJSON(Type.Float,obj["w"]) + }; + case Type.V4_V4_Float: + return new V4> + { x = (V4)fromJSON(Type.V4_Float,obj["x"]) + , y = (V4)fromJSON(Type.V4_Float,obj["y"]) + , z = (V4)fromJSON(Type.V4_Float,obj["z"]) + , w = (V4)fromJSON(Type.V4_Float,obj["w"]) + }; + case Type.Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList(); + case Type.Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList(); + case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList(); + case Type.Array_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_Float, x)).ToList(); + case Type.Array_V2_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_V2_Float, x)).ToList(); + case Type.Array_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_Float, x)).ToList(); + case Type.Array_V3_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_V3_Float, x)).ToList(); + case Type.Array_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_Float, x)).ToList(); + case Type.Array_V4_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_V4_Float, x)).ToList(); + case Type.Map_String_MeshAttribute: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.Mesh.MeshAttribute)fromJSON(Type.MeshAttribute,i.Value)); + } + return map; + } + + case Type.MeshAttribute: { + string tag = (string)obj["tag"]; + MeshAttribute.Tag tagType; + if (tag == "A_Float") { + tagType = MeshAttribute.Tag.A_Float; + data.A_Float tv = new data.A_Float(); + tv._0 = (List)fromJSON(Type.Array_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_V2F") { + tagType = MeshAttribute.Tag.A_V2F; + data.A_V2F tv = new data.A_V2F(); + tv._0 = (List>)fromJSON(Type.Array_V2_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_V3F") { + tagType = MeshAttribute.Tag.A_V3F; + data.A_V3F tv = new data.A_V3F(); + tv._0 = (List>)fromJSON(Type.Array_V3_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_V4F") { + tagType = MeshAttribute.Tag.A_V4F; + data.A_V4F tv = new data.A_V4F(); + tv._0 = (List>)fromJSON(Type.Array_V4_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_M22F") { + tagType = MeshAttribute.Tag.A_M22F; + data.A_M22F tv = new data.A_M22F(); + tv._0 = (List>>)fromJSON(Type.Array_V2_V2_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_M33F") { + tagType = MeshAttribute.Tag.A_M33F; + data.A_M33F tv = new data.A_M33F(); + tv._0 = (List>>)fromJSON(Type.Array_V3_V3_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_M44F") { + tagType = MeshAttribute.Tag.A_M44F; + data.A_M44F tv = new data.A_M44F(); + tv._0 = (List>>)fromJSON(Type.Array_V4_V4_Float,obj["arg0"]); + return tv; + } + else if (tag == "A_Int") { + tagType = MeshAttribute.Tag.A_Int; + data.A_Int tv = new data.A_Int(); + tv._0 = (List)fromJSON(Type.Array_Int32,obj["arg0"]); + return tv; + } + else if (tag == "A_Word") { + tagType = MeshAttribute.Tag.A_Word; + data.A_Word tv = new data.A_Word(); + tv._0 = (List)fromJSON(Type.Array_Word32,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + MeshAttribute o = new MeshAttribute(); + o.tag = tagType; + return o; + } + case Type.MeshPrimitive: { + string tag = (string)obj["tag"]; + MeshPrimitive.Tag tagType; + if (tag == "P_Points") { + tagType = MeshPrimitive.Tag.P_Points; + } + else if (tag == "P_TriangleStrip") { + tagType = MeshPrimitive.Tag.P_TriangleStrip; + } + else if (tag == "P_Triangles") { + tagType = MeshPrimitive.Tag.P_Triangles; + } + else if (tag == "P_TriangleStripI") { + tagType = MeshPrimitive.Tag.P_TriangleStripI; + data.P_TriangleStripI tv = new data.P_TriangleStripI(); + tv._0 = (List)fromJSON(Type.Array_Int32,obj["arg0"]); + return tv; + } + else if (tag == "P_TrianglesI") { + tagType = MeshPrimitive.Tag.P_TrianglesI; + data.P_TrianglesI tv = new data.P_TrianglesI(); + tv._0 = (List)fromJSON(Type.Array_Int32,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + MeshPrimitive o = new MeshPrimitive(); + o.tag = tagType; + return o; + } + case Type.Mesh: { + string tag = (string)obj["tag"]; + Mesh.Tag tagType; + if (tag == "Mesh") { + tagType = Mesh.Tag.Mesh; + data.Mesh tv = new data.Mesh(); + tv.mAttributes = (Dictionary)fromJSON(Type.Map_String_MeshAttribute,obj["mAttributes"]); + tv.mPrimitive = (global::LambdaCube.Mesh.MeshPrimitive)fromJSON(Type.MeshPrimitive,obj["mPrimitive"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Mesh o = new Mesh(); + o.tag = tagType; + return o; + } + } + throw new Exception("unknown type"); + return null; + } + + JToken toJSON(MeshAttribute v) { + var obj = new JObject(); + switch (v.tag) { + case MeshAttribute.Tag.A_Float: + obj["tag"] = "A_Float"; + { + var tv = (data.A_Float)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_V2F: + obj["tag"] = "A_V2F"; + { + var tv = (data.A_V2F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_V3F: + obj["tag"] = "A_V3F"; + { + var tv = (data.A_V3F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_V4F: + obj["tag"] = "A_V4F"; + { + var tv = (data.A_V4F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_M22F: + obj["tag"] = "A_M22F"; + { + var tv = (data.A_M22F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_M33F: + obj["tag"] = "A_M33F"; + { + var tv = (data.A_M33F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_M44F: + obj["tag"] = "A_M44F"; + { + var tv = (data.A_M44F)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_Int: + obj["tag"] = "A_Int"; + { + var tv = (data.A_Int)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshAttribute.Tag.A_Word: + obj["tag"] = "A_Word"; + { + var tv = (data.A_Word)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(MeshPrimitive v) { + var obj = new JObject(); + switch (v.tag) { + case MeshPrimitive.Tag.P_Points: + obj["tag"] = "P_Points"; + break; + case MeshPrimitive.Tag.P_TriangleStrip: + obj["tag"] = "P_TriangleStrip"; + break; + case MeshPrimitive.Tag.P_Triangles: + obj["tag"] = "P_Triangles"; + break; + case MeshPrimitive.Tag.P_TriangleStripI: + obj["tag"] = "P_TriangleStripI"; + { + var tv = (data.P_TriangleStripI)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case MeshPrimitive.Tag.P_TrianglesI: + obj["tag"] = "P_TrianglesI"; + { + var tv = (data.P_TrianglesI)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + JToken toJSON(Mesh v) { + var obj = new JObject(); + switch (v.tag) { + case Mesh.Tag.Mesh: + obj["tag"] = "Mesh"; + { + var tv = (data.Mesh)v; + obj["mAttributes"] = toJSON(tv.mAttributes); + obj["mPrimitive"] = toJSON(tv.mPrimitive); + } + break; + } + return obj; + } + + JToken toJSON(int v) { return new JValue(v); } + JToken toJSON(uint v) { return new JValue(v); } + JToken toJSON(float v) { return new JValue(v); } + JToken toJSON(string v) { return new JValue(v); } + JToken toJSON(V2 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V2> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + JToken toJSON(V3 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V3> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + JToken toJSON(V4 v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(V4> v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List> v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List>> v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List> v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List>> v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List> v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List>> v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + } +} diff --git a/ddl/out/LambdaCube.Mesh.hpp b/ddl/out/LambdaCube.Mesh.hpp index 29bb2ba..d0899fd 100644 --- a/ddl/out/LambdaCube.Mesh.hpp +++ b/ddl/out/LambdaCube.Mesh.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.781208000000Z +======= +// 2016-03-20T21:42:12.936741000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.Mesh_H #define HEADER_LambdaCube.Mesh_H diff --git a/ddl/out/LambdaCube.Mesh.hs b/ddl/out/LambdaCube.Mesh.hs index 1e7926a..ddf90c9 100644 --- a/ddl/out/LambdaCube.Mesh.hs +++ b/ddl/out/LambdaCube.Mesh.hs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.781208000000Z +======= +-- 2016-03-20T21:42:12.936741000000Z +>>>>>>> working c# backend {-# LANGUAGE OverloadedStrings, RecordWildCards #-} module LambdaCube.Mesh where diff --git a/ddl/out/LambdaCube.Mesh.java b/ddl/out/LambdaCube.Mesh.java new file mode 100644 index 0000000..2cf85c7 --- /dev/null +++ b/ddl/out/LambdaCube.Mesh.java @@ -0,0 +1,79 @@ +// generated file, do not modify! +// 2016-03-14T10:58:29.976813000000Z + + +public class LambdaCube.Mesh { + public class MeshAttribute { + public enum Tag { + A_Float, + A_V2F, + A_V3F, + A_V4F, + A_M22F, + A_M33F, + A_M44F, + A_Int, + A_Word + } + public Tag tag; + + public class A_Float extends MeshAttribute { + public ArrayList _0; + } + public class A_V2F extends MeshAttribute { + public ArrayList _0; + } + public class A_V3F extends MeshAttribute { + public ArrayList _0; + } + public class A_V4F extends MeshAttribute { + public ArrayList _0; + } + public class A_M22F extends MeshAttribute { + public ArrayList _0; + } + public class A_M33F extends MeshAttribute { + public ArrayList _0; + } + public class A_M44F extends MeshAttribute { + public ArrayList _0; + } + public class A_Int extends MeshAttribute { + public ArrayList _0; + } + public class A_Word extends MeshAttribute { + public ArrayList _0; + } + } + + public class MeshPrimitive { + public enum Tag { + P_Points, + P_TriangleStrip, + P_Triangles, + P_TriangleStripI, + P_TrianglesI + } + public Tag tag; + + public class P_TriangleStripI extends MeshPrimitive { + public ArrayList _0; + } + public class P_TrianglesI extends MeshPrimitive { + public ArrayList _0; + } + } + + public class Mesh { + public enum Tag { + Mesh + } + public Tag tag; + + public class Mesh extends Mesh { + public HashMap mAttributes; + public MeshPrimitive mPrimitive; + } + } + +} \ No newline at end of file diff --git a/ddl/out/LambdaCube.Mesh.purs b/ddl/out/LambdaCube.Mesh.purs index 22a8380..60a61e2 100644 --- a/ddl/out/LambdaCube.Mesh.purs +++ b/ddl/out/LambdaCube.Mesh.purs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.781208000000Z +======= +-- 2016-03-20T21:42:12.936741000000Z +>>>>>>> working c# backend module LambdaCube.Mesh where import Prelude diff --git a/ddl/out/LambdaCube.Mesh.swift b/ddl/out/LambdaCube.Mesh.swift index e300c0f..ff4ac52 100644 --- a/ddl/out/LambdaCube.Mesh.swift +++ b/ddl/out/LambdaCube.Mesh.swift @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.781208000000Z +======= +// 2016-03-20T21:42:12.936741000000Z +>>>>>>> working c# backend enum MeshAttribute { case A_Float(Array) diff --git a/ddl/out/LambdaCube.Mesh2.hpp b/ddl/out/LambdaCube.Mesh2.hpp index 56cf730..fc84a17 100644 --- a/ddl/out/LambdaCube.Mesh2.hpp +++ b/ddl/out/LambdaCube.Mesh2.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.781208000000Z +======= +// 2016-03-20T21:42:12.936741000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.Mesh_H #define HEADER_LambdaCube.Mesh_H diff --git a/ddl/out/LambdaCube.PipelineSchema.cpp b/ddl/out/LambdaCube.PipelineSchema.cpp index 9e2604a..450bf72 100644 --- a/ddl/out/LambdaCube.PipelineSchema.cpp +++ b/ddl/out/LambdaCube.PipelineSchema.cpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.761274000000Z +======= +// 2016-03-20T21:42:12.892571000000Z +>>>>>>> working c# backend #include "LambdaCube.PipelineSchema.hpp" template<> json toJSON>(std::shared_ptr &v) { diff --git a/ddl/out/LambdaCube.PipelineSchema.cs b/ddl/out/LambdaCube.PipelineSchema.cs new file mode 100644 index 0000000..945ae0c --- /dev/null +++ b/ddl/out/LambdaCube.PipelineSchema.cs @@ -0,0 +1,339 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.343859000000Z + +using System; +using System.Linq; +using System.Collections.Generic; +using Newtonsoft.Json.Linq; + +using LambdaCube.IR; + +namespace LambdaCube.PipelineSchema { + class StreamType { + public enum Tag { + Attribute_Word, + Attribute_V2U, + Attribute_V3U, + Attribute_V4U, + Attribute_Int, + Attribute_V2I, + Attribute_V3I, + Attribute_V4I, + Attribute_Float, + Attribute_V2F, + Attribute_V3F, + Attribute_V4F, + Attribute_M22F, + Attribute_M23F, + Attribute_M24F, + Attribute_M32F, + Attribute_M33F, + Attribute_M34F, + Attribute_M42F, + Attribute_M43F, + Attribute_M44F + }; + public Tag tag; + }; + + namespace data { + } + class ObjectArraySchema { + public enum Tag { + ObjectArraySchema + }; + public Tag tag; + }; + + namespace data { + class ObjectArraySchema : LambdaCube.PipelineSchema.ObjectArraySchema { + public global::LambdaCube.PipelineSchema.FetchPrimitive primitive; + public Dictionary attributes; + public ObjectArraySchema() { tag = LambdaCube.PipelineSchema.ObjectArraySchema.Tag.ObjectArraySchema; } + }; + } + class PipelineSchema { + public enum Tag { + PipelineSchema + }; + public Tag tag; + }; + + namespace data { + class PipelineSchema : LambdaCube.PipelineSchema.PipelineSchema { + public Dictionary objectArrays; + public Dictionary uniforms; + public PipelineSchema() { tag = LambdaCube.PipelineSchema.PipelineSchema.Tag.PipelineSchema; } + }; + } + + // JSON deserializer + enum Type { + String, + Map_String_InputType, + Map_String_ObjectArraySchema, + Map_String_StreamType, + FetchPrimitive, + InputType, + ObjectArraySchema, + PipelineSchema, + StreamType + } + + class Loader { + public static object fromJSON(Type type, JToken obj) { + switch (type) { + case Type.String: return (string)obj; + case Type.Map_String_InputType: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.PipelineSchema.InputType)fromJSON(Type.InputType,i.Value)); + } + return map; + } + case Type.Map_String_ObjectArraySchema: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.PipelineSchema.ObjectArraySchema)fromJSON(Type.ObjectArraySchema,i.Value)); + } + return map; + } + case Type.Map_String_StreamType: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::LambdaCube.PipelineSchema.StreamType)fromJSON(Type.StreamType,i.Value)); + } + return map; + } + + case Type.StreamType: { + string tag = (string)obj["tag"]; + StreamType.Tag tagType; + if (tag == "Attribute_Word") { + tagType = StreamType.Tag.Attribute_Word; + } + else if (tag == "Attribute_V2U") { + tagType = StreamType.Tag.Attribute_V2U; + } + else if (tag == "Attribute_V3U") { + tagType = StreamType.Tag.Attribute_V3U; + } + else if (tag == "Attribute_V4U") { + tagType = StreamType.Tag.Attribute_V4U; + } + else if (tag == "Attribute_Int") { + tagType = StreamType.Tag.Attribute_Int; + } + else if (tag == "Attribute_V2I") { + tagType = StreamType.Tag.Attribute_V2I; + } + else if (tag == "Attribute_V3I") { + tagType = StreamType.Tag.Attribute_V3I; + } + else if (tag == "Attribute_V4I") { + tagType = StreamType.Tag.Attribute_V4I; + } + else if (tag == "Attribute_Float") { + tagType = StreamType.Tag.Attribute_Float; + } + else if (tag == "Attribute_V2F") { + tagType = StreamType.Tag.Attribute_V2F; + } + else if (tag == "Attribute_V3F") { + tagType = StreamType.Tag.Attribute_V3F; + } + else if (tag == "Attribute_V4F") { + tagType = StreamType.Tag.Attribute_V4F; + } + else if (tag == "Attribute_M22F") { + tagType = StreamType.Tag.Attribute_M22F; + } + else if (tag == "Attribute_M23F") { + tagType = StreamType.Tag.Attribute_M23F; + } + else if (tag == "Attribute_M24F") { + tagType = StreamType.Tag.Attribute_M24F; + } + else if (tag == "Attribute_M32F") { + tagType = StreamType.Tag.Attribute_M32F; + } + else if (tag == "Attribute_M33F") { + tagType = StreamType.Tag.Attribute_M33F; + } + else if (tag == "Attribute_M34F") { + tagType = StreamType.Tag.Attribute_M34F; + } + else if (tag == "Attribute_M42F") { + tagType = StreamType.Tag.Attribute_M42F; + } + else if (tag == "Attribute_M43F") { + tagType = StreamType.Tag.Attribute_M43F; + } + else if (tag == "Attribute_M44F") { + tagType = StreamType.Tag.Attribute_M44F; + } + else throw new Exception("unknown constructor: " + tag); + StreamType o = new StreamType(); + o.tag = tagType; + return o; + } + case Type.ObjectArraySchema: { + string tag = (string)obj["tag"]; + ObjectArraySchema.Tag tagType; + if (tag == "ObjectArraySchema") { + tagType = ObjectArraySchema.Tag.ObjectArraySchema; + data.ObjectArraySchema tv = new data.ObjectArraySchema(); + tv.primitive = (global::LambdaCube.PipelineSchema.FetchPrimitive)fromJSON(Type.FetchPrimitive,obj["primitive"]); + tv.attributes = (Dictionary)fromJSON(Type.Map_String_StreamType,obj["attributes"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + ObjectArraySchema o = new ObjectArraySchema(); + o.tag = tagType; + return o; + } + case Type.PipelineSchema: { + string tag = (string)obj["tag"]; + PipelineSchema.Tag tagType; + if (tag == "PipelineSchema") { + tagType = PipelineSchema.Tag.PipelineSchema; + data.PipelineSchema tv = new data.PipelineSchema(); + tv.objectArrays = (Dictionary)fromJSON(Type.Map_String_ObjectArraySchema,obj["objectArrays"]); + tv.uniforms = (Dictionary)fromJSON(Type.Map_String_InputType,obj["uniforms"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + PipelineSchema o = new PipelineSchema(); + o.tag = tagType; + return o; + } + } + throw new Exception("unknown type"); + return null; + } + + JToken toJSON(StreamType v) { + var obj = new JObject(); + switch (v.tag) { + case StreamType.Tag.Attribute_Word: + obj["tag"] = "Attribute_Word"; + break; + case StreamType.Tag.Attribute_V2U: + obj["tag"] = "Attribute_V2U"; + break; + case StreamType.Tag.Attribute_V3U: + obj["tag"] = "Attribute_V3U"; + break; + case StreamType.Tag.Attribute_V4U: + obj["tag"] = "Attribute_V4U"; + break; + case StreamType.Tag.Attribute_Int: + obj["tag"] = "Attribute_Int"; + break; + case StreamType.Tag.Attribute_V2I: + obj["tag"] = "Attribute_V2I"; + break; + case StreamType.Tag.Attribute_V3I: + obj["tag"] = "Attribute_V3I"; + break; + case StreamType.Tag.Attribute_V4I: + obj["tag"] = "Attribute_V4I"; + break; + case StreamType.Tag.Attribute_Float: + obj["tag"] = "Attribute_Float"; + break; + case StreamType.Tag.Attribute_V2F: + obj["tag"] = "Attribute_V2F"; + break; + case StreamType.Tag.Attribute_V3F: + obj["tag"] = "Attribute_V3F"; + break; + case StreamType.Tag.Attribute_V4F: + obj["tag"] = "Attribute_V4F"; + break; + case StreamType.Tag.Attribute_M22F: + obj["tag"] = "Attribute_M22F"; + break; + case StreamType.Tag.Attribute_M23F: + obj["tag"] = "Attribute_M23F"; + break; + case StreamType.Tag.Attribute_M24F: + obj["tag"] = "Attribute_M24F"; + break; + case StreamType.Tag.Attribute_M32F: + obj["tag"] = "Attribute_M32F"; + break; + case StreamType.Tag.Attribute_M33F: + obj["tag"] = "Attribute_M33F"; + break; + case StreamType.Tag.Attribute_M34F: + obj["tag"] = "Attribute_M34F"; + break; + case StreamType.Tag.Attribute_M42F: + obj["tag"] = "Attribute_M42F"; + break; + case StreamType.Tag.Attribute_M43F: + obj["tag"] = "Attribute_M43F"; + break; + case StreamType.Tag.Attribute_M44F: + obj["tag"] = "Attribute_M44F"; + break; + } + return obj; + } + JToken toJSON(ObjectArraySchema v) { + var obj = new JObject(); + switch (v.tag) { + case ObjectArraySchema.Tag.ObjectArraySchema: + obj["tag"] = "ObjectArraySchema"; + { + var tv = (data.ObjectArraySchema)v; + obj["primitive"] = toJSON(tv.primitive); + obj["attributes"] = toJSON(tv.attributes); + } + break; + } + return obj; + } + JToken toJSON(PipelineSchema v) { + var obj = new JObject(); + switch (v.tag) { + case PipelineSchema.Tag.PipelineSchema: + obj["tag"] = "PipelineSchema"; + { + var tv = (data.PipelineSchema)v; + obj["objectArrays"] = toJSON(tv.objectArrays); + obj["uniforms"] = toJSON(tv.uniforms); + } + break; + } + return obj; + } + + JToken toJSON(string v) { return new JValue(v); } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + } +} diff --git a/ddl/out/LambdaCube.PipelineSchema.hpp b/ddl/out/LambdaCube.PipelineSchema.hpp index 82e9853..afddf06 100644 --- a/ddl/out/LambdaCube.PipelineSchema.hpp +++ b/ddl/out/LambdaCube.PipelineSchema.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.761274000000Z +======= +// 2016-03-20T21:42:12.892571000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.PipelineSchema_H #define HEADER_LambdaCube.PipelineSchema_H diff --git a/ddl/out/LambdaCube.PipelineSchema.hs b/ddl/out/LambdaCube.PipelineSchema.hs index ba83200..90ad67a 100644 --- a/ddl/out/LambdaCube.PipelineSchema.hs +++ b/ddl/out/LambdaCube.PipelineSchema.hs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.761274000000Z +======= +-- 2016-03-20T21:42:12.892571000000Z +>>>>>>> working c# backend {-# LANGUAGE OverloadedStrings, RecordWildCards #-} module LambdaCube.PipelineSchema where diff --git a/ddl/out/LambdaCube.PipelineSchema.java b/ddl/out/LambdaCube.PipelineSchema.java new file mode 100644 index 0000000..c71e7c0 --- /dev/null +++ b/ddl/out/LambdaCube.PipelineSchema.java @@ -0,0 +1,59 @@ +// generated file, do not modify! +// 2016-03-14T10:58:29.954220000000Z + +import LambdaCube.IR; + +public class LambdaCube.PipelineSchema { + public class StreamType { + public enum Tag { + Attribute_Word, + Attribute_V2U, + Attribute_V3U, + Attribute_V4U, + Attribute_Int, + Attribute_V2I, + Attribute_V3I, + Attribute_V4I, + Attribute_Float, + Attribute_V2F, + Attribute_V3F, + Attribute_V4F, + Attribute_M22F, + Attribute_M23F, + Attribute_M24F, + Attribute_M32F, + Attribute_M33F, + Attribute_M34F, + Attribute_M42F, + Attribute_M43F, + Attribute_M44F + } + public Tag tag; + + } + + public class ObjectArraySchema { + public enum Tag { + ObjectArraySchema + } + public Tag tag; + + public class ObjectArraySchema extends ObjectArraySchema { + public FetchPrimitive primitive; + public HashMap attributes; + } + } + + public class PipelineSchema { + public enum Tag { + PipelineSchema + } + public Tag tag; + + public class PipelineSchema extends PipelineSchema { + public HashMap objectArrays; + public HashMap uniforms; + } + } + +} \ No newline at end of file diff --git a/ddl/out/LambdaCube.PipelineSchema.purs b/ddl/out/LambdaCube.PipelineSchema.purs index 1f741cb..a1919a1 100644 --- a/ddl/out/LambdaCube.PipelineSchema.purs +++ b/ddl/out/LambdaCube.PipelineSchema.purs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.761274000000Z +======= +-- 2016-03-20T21:42:12.892571000000Z +>>>>>>> working c# backend module LambdaCube.PipelineSchema where import Prelude diff --git a/ddl/out/LambdaCube.PipelineSchema.swift b/ddl/out/LambdaCube.PipelineSchema.swift index 0c48df8..418ed7b 100644 --- a/ddl/out/LambdaCube.PipelineSchema.swift +++ b/ddl/out/LambdaCube.PipelineSchema.swift @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.761274000000Z +======= +// 2016-03-20T21:42:12.892571000000Z +>>>>>>> working c# backend enum StreamType { case Attribute_Word diff --git a/ddl/out/LambdaCube.PipelineSchema2.hpp b/ddl/out/LambdaCube.PipelineSchema2.hpp index 691aa9b..9d5acfe 100644 --- a/ddl/out/LambdaCube.PipelineSchema2.hpp +++ b/ddl/out/LambdaCube.PipelineSchema2.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.761274000000Z +======= +// 2016-03-20T21:42:12.892571000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.PipelineSchema_H #define HEADER_LambdaCube.PipelineSchema_H diff --git a/ddl/out/LambdaCube.TypeInfo.cpp b/ddl/out/LambdaCube.TypeInfo.cpp index bf793c3..a32436c 100644 --- a/ddl/out/LambdaCube.TypeInfo.cpp +++ b/ddl/out/LambdaCube.TypeInfo.cpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.810157000000Z +======= +// 2016-03-20T21:42:12.996366000000Z +>>>>>>> working c# backend #include "LambdaCube.TypeInfo.hpp" template<> json toJSON>(std::shared_ptr &v) { diff --git a/ddl/out/LambdaCube.TypeInfo.cs b/ddl/out/LambdaCube.TypeInfo.cs new file mode 100644 index 0000000..967aa01 --- /dev/null +++ b/ddl/out/LambdaCube.TypeInfo.cs @@ -0,0 +1,218 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.460562000000Z + +using System; +using System.Linq; +using System.Collections.Generic; +using Newtonsoft.Json.Linq; + +using LambdaCube.IR; + +namespace LambdaCube.TypeInfo { + class Range { + public enum Tag { + Range + }; + public Tag tag; + }; + + namespace data { + class Range : LambdaCube.TypeInfo.Range { + public int startLine; + public int startColumn; + public int endLine; + public int endColumn; + public Range() { tag = LambdaCube.TypeInfo.Range.Tag.Range; } + }; + } + class TypeInfo { + public enum Tag { + TypeInfo + }; + public Tag tag; + }; + + namespace data { + class TypeInfo : LambdaCube.TypeInfo.TypeInfo { + public global::LambdaCube.TypeInfo.Range range; + public string text; + public TypeInfo() { tag = LambdaCube.TypeInfo.TypeInfo.Tag.TypeInfo; } + }; + } + class CompileResult { + public enum Tag { + CompileError, + Compiled + }; + public Tag tag; + }; + + namespace data { + class CompileError : LambdaCube.TypeInfo.CompileResult { + public List _0; + public string _1; + public List _2; + public CompileError() { tag = LambdaCube.TypeInfo.CompileResult.Tag.CompileError; } + }; + class Compiled : LambdaCube.TypeInfo.CompileResult { + public string _0; + public global::LambdaCube.TypeInfo.Pipeline _1; + public List _2; + public Compiled() { tag = LambdaCube.TypeInfo.CompileResult.Tag.Compiled; } + }; + } + + // JSON deserializer + enum Type { + Int, + String, + Array_Range, + Array_TypeInfo, + CompileResult, + Pipeline, + Range, + TypeInfo + } + + class Loader { + public static object fromJSON(Type type, JToken obj) { + switch (type) { + case Type.Int: return (int)obj; + case Type.String: return (string)obj; + case Type.Array_Range: return ((JArray)obj).Select(x => fromJSON (Type.Range, x)).ToList(); + case Type.Array_TypeInfo: return ((JArray)obj).Select(x => fromJSON (Type.TypeInfo, x)).ToList(); + + case Type.Range: { + string tag = (string)obj["tag"]; + Range.Tag tagType; + if (tag == "Range") { + tagType = Range.Tag.Range; + data.Range tv = new data.Range(); + tv.startLine = (int)fromJSON(Type.Int,obj["startLine"]); + tv.startColumn = (int)fromJSON(Type.Int,obj["startColumn"]); + tv.endLine = (int)fromJSON(Type.Int,obj["endLine"]); + tv.endColumn = (int)fromJSON(Type.Int,obj["endColumn"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Range o = new Range(); + o.tag = tagType; + return o; + } + case Type.TypeInfo: { + string tag = (string)obj["tag"]; + TypeInfo.Tag tagType; + if (tag == "TypeInfo") { + tagType = TypeInfo.Tag.TypeInfo; + data.TypeInfo tv = new data.TypeInfo(); + tv.range = (global::LambdaCube.TypeInfo.Range)fromJSON(Type.Range,obj["range"]); + tv.text = (string)fromJSON(Type.String,obj["text"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + TypeInfo o = new TypeInfo(); + o.tag = tagType; + return o; + } + case Type.CompileResult: { + string tag = (string)obj["tag"]; + CompileResult.Tag tagType; + if (tag == "CompileError") { + tagType = CompileResult.Tag.CompileError; + data.CompileError tv = new data.CompileError(); + tv._0 = (List)fromJSON(Type.Array_Range,obj["arg0"]); + tv._1 = (string)fromJSON(Type.String,obj["arg1"]); + tv._2 = (List)fromJSON(Type.Array_TypeInfo,obj["arg2"]); + return tv; + } + else if (tag == "Compiled") { + tagType = CompileResult.Tag.Compiled; + data.Compiled tv = new data.Compiled(); + tv._0 = (string)fromJSON(Type.String,obj["arg0"]); + tv._1 = (global::LambdaCube.TypeInfo.Pipeline)fromJSON(Type.Pipeline,obj["arg1"]); + tv._2 = (List)fromJSON(Type.Array_TypeInfo,obj["arg2"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + CompileResult o = new CompileResult(); + o.tag = tagType; + return o; + } + } + throw new Exception("unknown type"); + return null; + } + + JToken toJSON(Range v) { + var obj = new JObject(); + switch (v.tag) { + case Range.Tag.Range: + obj["tag"] = "Range"; + { + var tv = (data.Range)v; + obj["startLine"] = toJSON(tv.startLine); + obj["startColumn"] = toJSON(tv.startColumn); + obj["endLine"] = toJSON(tv.endLine); + obj["endColumn"] = toJSON(tv.endColumn); + } + break; + } + return obj; + } + JToken toJSON(TypeInfo v) { + var obj = new JObject(); + switch (v.tag) { + case TypeInfo.Tag.TypeInfo: + obj["tag"] = "TypeInfo"; + { + var tv = (data.TypeInfo)v; + obj["range"] = toJSON(tv.range); + obj["text"] = toJSON(tv.text); + } + break; + } + return obj; + } + JToken toJSON(CompileResult v) { + var obj = new JObject(); + switch (v.tag) { + case CompileResult.Tag.CompileError: + obj["tag"] = "CompileError"; + { + var tv = (data.CompileError)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + } + break; + case CompileResult.Tag.Compiled: + obj["tag"] = "Compiled"; + { + var tv = (data.Compiled)v; + obj["arg0"] = toJSON(tv._0); + obj["arg1"] = toJSON(tv._1); + obj["arg2"] = toJSON(tv._2); + } + break; + } + return obj; + } + + JToken toJSON(int v) { return new JValue(v); } + JToken toJSON(string v) { return new JValue(v); } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + } +} diff --git a/ddl/out/LambdaCube.TypeInfo.hpp b/ddl/out/LambdaCube.TypeInfo.hpp index 66a4eba..05fbd45 100644 --- a/ddl/out/LambdaCube.TypeInfo.hpp +++ b/ddl/out/LambdaCube.TypeInfo.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.810157000000Z +======= +// 2016-03-20T21:42:12.996366000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.TypeInfo_H #define HEADER_LambdaCube.TypeInfo_H diff --git a/ddl/out/LambdaCube.TypeInfo.hs b/ddl/out/LambdaCube.TypeInfo.hs index 77ccbfd..fa8ddc6 100644 --- a/ddl/out/LambdaCube.TypeInfo.hs +++ b/ddl/out/LambdaCube.TypeInfo.hs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.810157000000Z +======= +-- 2016-03-20T21:42:12.996366000000Z +>>>>>>> working c# backend {-# LANGUAGE OverloadedStrings, RecordWildCards #-} module LambdaCube.TypeInfo where diff --git a/ddl/out/LambdaCube.TypeInfo.java b/ddl/out/LambdaCube.TypeInfo.java new file mode 100644 index 0000000..59c2a26 --- /dev/null +++ b/ddl/out/LambdaCube.TypeInfo.java @@ -0,0 +1,52 @@ +// generated file, do not modify! +// 2016-03-14T10:58:30.014693000000Z + +import LambdaCube.IR; + +public class LambdaCube.TypeInfo { + public class Range { + public enum Tag { + Range + } + public Tag tag; + + public class Range extends Range { + public Integer startLine; + public Integer startColumn; + public Integer endLine; + public Integer endColumn; + } + } + + public class TypeInfo { + public enum Tag { + TypeInfo + } + public Tag tag; + + public class TypeInfo extends TypeInfo { + public Range range; + public String text; + } + } + + public class CompileResult { + public enum Tag { + CompileError, + Compiled + } + public Tag tag; + + public class CompileError extends CompileResult { + public ArrayList _0; + public String _1; + public ArrayList _2; + } + public class Compiled extends CompileResult { + public String _0; + public Pipeline _1; + public ArrayList _2; + } + } + +} \ No newline at end of file diff --git a/ddl/out/LambdaCube.TypeInfo.purs b/ddl/out/LambdaCube.TypeInfo.purs index 1b7cef8..b33afda 100644 --- a/ddl/out/LambdaCube.TypeInfo.purs +++ b/ddl/out/LambdaCube.TypeInfo.purs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.810157000000Z +======= +-- 2016-03-20T21:42:12.996366000000Z +>>>>>>> working c# backend module LambdaCube.TypeInfo where import Prelude diff --git a/ddl/out/LambdaCube.TypeInfo.swift b/ddl/out/LambdaCube.TypeInfo.swift index 8bb041f..e4776e9 100644 --- a/ddl/out/LambdaCube.TypeInfo.swift +++ b/ddl/out/LambdaCube.TypeInfo.swift @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.810157000000Z +======= +// 2016-03-20T21:42:12.996366000000Z +>>>>>>> working c# backend enum Range { case Range(Range_Data) diff --git a/ddl/out/LambdaCube.TypeInfo2.hpp b/ddl/out/LambdaCube.TypeInfo2.hpp index f80978f..8a69dcf 100644 --- a/ddl/out/LambdaCube.TypeInfo2.hpp +++ b/ddl/out/LambdaCube.TypeInfo2.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.810157000000Z +======= +// 2016-03-20T21:42:12.996366000000Z +>>>>>>> working c# backend #ifndef HEADER_LambdaCube.TypeInfo_H #define HEADER_LambdaCube.TypeInfo_H diff --git a/ddl/out/TestData.cpp b/ddl/out/TestData.cpp index 8b2cdf5..b7d4d31 100644 --- a/ddl/out/TestData.cpp +++ b/ddl/out/TestData.cpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.829757000000Z +======= +// 2016-03-20T21:42:13.043021000000Z +>>>>>>> working c# backend #include "TestData.hpp" template<> json toJSON>(std::shared_ptr &v) { diff --git a/ddl/out/TestData.cs b/ddl/out/TestData.cs new file mode 100644 index 0000000..0ea14a3 --- /dev/null +++ b/ddl/out/TestData.cs @@ -0,0 +1,499 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +using System; +using System.Linq; +using System.Collections.Generic; +using Newtonsoft.Json.Linq; + +using LambdaCube.IR; +using LambdaCube.Mesh; +using LambdaCube.PipelineSchema; + +namespace TestData { + class ClientInfo { + public enum Tag { + ClientInfo + }; + public Tag tag; + }; + + namespace data { + class ClientInfo : TestData.ClientInfo { + public string clientName; + public global::TestData.Backend clientBackend; + public ClientInfo() { tag = TestData.ClientInfo.Tag.ClientInfo; } + }; + } + class Frame { + public enum Tag { + Frame + }; + public Tag tag; + }; + + namespace data { + class Frame : TestData.Frame { + public int renderCount; + public Dictionary frameUniforms; + public Dictionary frameTextures; + public Frame() { tag = TestData.Frame.Tag.Frame; } + }; + } + class Scene { + public enum Tag { + Scene + }; + public Tag tag; + }; + + namespace data { + class Scene : TestData.Scene { + public Dictionary> objectArrays; + public int renderTargetWidth; + public int renderTargetHeight; + public List frames; + public Scene() { tag = TestData.Scene.Tag.Scene; } + }; + } + class PipelineInfo { + public enum Tag { + PipelineInfo + }; + public Tag tag; + }; + + namespace data { + class PipelineInfo : TestData.PipelineInfo { + public string pipelineName; + public global::TestData.Pipeline pipeline; + public PipelineInfo() { tag = TestData.PipelineInfo.Tag.PipelineInfo; } + }; + } + class RenderJob { + public enum Tag { + RenderJob + }; + public Tag tag; + }; + + namespace data { + class RenderJob : TestData.RenderJob { + public List meshes; + public List textures; + public global::TestData.PipelineSchema schema; + public List scenes; + public List pipelines; + public RenderJob() { tag = TestData.RenderJob.Tag.RenderJob; } + }; + } + class FrameResult { + public enum Tag { + FrameResult + }; + public Tag tag; + }; + + namespace data { + class FrameResult : TestData.FrameResult { + public List frRenderTimes; + public int frImageWidth; + public int frImageHeight; + public FrameResult() { tag = TestData.FrameResult.Tag.FrameResult; } + }; + } + class RenderJobResult { + public enum Tag { + RenderJobResult, + RenderJobError + }; + public Tag tag; + }; + + namespace data { + class RenderJobResult : TestData.RenderJobResult { + public global::TestData.FrameResult _0; + public RenderJobResult() { tag = TestData.RenderJobResult.Tag.RenderJobResult; } + }; + class RenderJobError : TestData.RenderJobResult { + public string _0; + public RenderJobError() { tag = TestData.RenderJobResult.Tag.RenderJobError; } + }; + } + + // JSON deserializer + enum Type { + Int, + Float, + String, + Array_Int, + Array_Float, + Array_String, + Array_Frame, + Array_Mesh, + Array_PipelineInfo, + Array_Scene, + Map_String_Int, + Map_String_Array_Int, + Map_String_Value, + Backend, + ClientInfo, + Frame, + FrameResult, + Mesh, + Pipeline, + PipelineInfo, + PipelineSchema, + RenderJob, + RenderJobResult, + Scene, + Value + } + + class Loader { + public static object fromJSON(Type type, JToken obj) { + switch (type) { + case Type.Int: return (int)obj; + case Type.Float: return (float)obj; + case Type.String: return (string)obj; + case Type.Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList(); + case Type.Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList(); + case Type.Array_String: return ((JArray)obj).Select(x => fromJSON (Type.String, x)).ToList(); + case Type.Array_Frame: return ((JArray)obj).Select(x => fromJSON (Type.Frame, x)).ToList(); + case Type.Array_Mesh: return ((JArray)obj).Select(x => fromJSON (Type.Mesh, x)).ToList(); + case Type.Array_PipelineInfo: return ((JArray)obj).Select(x => fromJSON (Type.PipelineInfo, x)).ToList(); + case Type.Array_Scene: return ((JArray)obj).Select(x => fromJSON (Type.Scene, x)).ToList(); + case Type.Map_String_Int: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (int)fromJSON(Type.Int,i.Value)); + } + return map; + } + case Type.Map_String_Array_Int: { + var map = new Dictionary> (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (List)fromJSON(Type.Array_Int,i.Value)); + } + return map; + } + case Type.Map_String_Value: { + var map = new Dictionary (); + foreach(var i in (JObject)obj) { + map.Add( (string)fromJSON(Type.String,i.Key) + , (global::TestData.Value)fromJSON(Type.Value,i.Value)); + } + return map; + } + + case Type.ClientInfo: { + string tag = (string)obj["tag"]; + ClientInfo.Tag tagType; + if (tag == "ClientInfo") { + tagType = ClientInfo.Tag.ClientInfo; + data.ClientInfo tv = new data.ClientInfo(); + tv.clientName = (string)fromJSON(Type.String,obj["clientName"]); + tv.clientBackend = (global::TestData.Backend)fromJSON(Type.Backend,obj["clientBackend"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + ClientInfo o = new ClientInfo(); + o.tag = tagType; + return o; + } + case Type.Frame: { + string tag = (string)obj["tag"]; + Frame.Tag tagType; + if (tag == "Frame") { + tagType = Frame.Tag.Frame; + data.Frame tv = new data.Frame(); + tv.renderCount = (int)fromJSON(Type.Int,obj["renderCount"]); + tv.frameUniforms = (Dictionary)fromJSON(Type.Map_String_Value,obj["frameUniforms"]); + tv.frameTextures = (Dictionary)fromJSON(Type.Map_String_Int,obj["frameTextures"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Frame o = new Frame(); + o.tag = tagType; + return o; + } + case Type.Scene: { + string tag = (string)obj["tag"]; + Scene.Tag tagType; + if (tag == "Scene") { + tagType = Scene.Tag.Scene; + data.Scene tv = new data.Scene(); + tv.objectArrays = (Dictionary>)fromJSON(Type.Map_String_Array_Int,obj["objectArrays"]); + tv.renderTargetWidth = (int)fromJSON(Type.Int,obj["renderTargetWidth"]); + tv.renderTargetHeight = (int)fromJSON(Type.Int,obj["renderTargetHeight"]); + tv.frames = (List)fromJSON(Type.Array_Frame,obj["frames"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + Scene o = new Scene(); + o.tag = tagType; + return o; + } + case Type.PipelineInfo: { + string tag = (string)obj["tag"]; + PipelineInfo.Tag tagType; + if (tag == "PipelineInfo") { + tagType = PipelineInfo.Tag.PipelineInfo; + data.PipelineInfo tv = new data.PipelineInfo(); + tv.pipelineName = (string)fromJSON(Type.String,obj["pipelineName"]); + tv.pipeline = (global::TestData.Pipeline)fromJSON(Type.Pipeline,obj["pipeline"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + PipelineInfo o = new PipelineInfo(); + o.tag = tagType; + return o; + } + case Type.RenderJob: { + string tag = (string)obj["tag"]; + RenderJob.Tag tagType; + if (tag == "RenderJob") { + tagType = RenderJob.Tag.RenderJob; + data.RenderJob tv = new data.RenderJob(); + tv.meshes = (List)fromJSON(Type.Array_Mesh,obj["meshes"]); + tv.textures = (List)fromJSON(Type.Array_String,obj["textures"]); + tv.schema = (global::TestData.PipelineSchema)fromJSON(Type.PipelineSchema,obj["schema"]); + tv.scenes = (List)fromJSON(Type.Array_Scene,obj["scenes"]); + tv.pipelines = (List)fromJSON(Type.Array_PipelineInfo,obj["pipelines"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + RenderJob o = new RenderJob(); + o.tag = tagType; + return o; + } + case Type.FrameResult: { + string tag = (string)obj["tag"]; + FrameResult.Tag tagType; + if (tag == "FrameResult") { + tagType = FrameResult.Tag.FrameResult; + data.FrameResult tv = new data.FrameResult(); + tv.frRenderTimes = (List)fromJSON(Type.Array_Float,obj["frRenderTimes"]); + tv.frImageWidth = (int)fromJSON(Type.Int,obj["frImageWidth"]); + tv.frImageHeight = (int)fromJSON(Type.Int,obj["frImageHeight"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + FrameResult o = new FrameResult(); + o.tag = tagType; + return o; + } + case Type.RenderJobResult: { + string tag = (string)obj["tag"]; + RenderJobResult.Tag tagType; + if (tag == "RenderJobResult") { + tagType = RenderJobResult.Tag.RenderJobResult; + data.RenderJobResult tv = new data.RenderJobResult(); + tv._0 = (global::TestData.FrameResult)fromJSON(Type.FrameResult,obj["arg0"]); + return tv; + } + else if (tag == "RenderJobError") { + tagType = RenderJobResult.Tag.RenderJobError; + data.RenderJobError tv = new data.RenderJobError(); + tv._0 = (string)fromJSON(Type.String,obj["arg0"]); + return tv; + } + else throw new Exception("unknown constructor: " + tag); + RenderJobResult o = new RenderJobResult(); + o.tag = tagType; + return o; + } + } + throw new Exception("unknown type"); + return null; + } + + JToken toJSON(ClientInfo v) { + var obj = new JObject(); + switch (v.tag) { + case ClientInfo.Tag.ClientInfo: + obj["tag"] = "ClientInfo"; + { + var tv = (data.ClientInfo)v; + obj["clientName"] = toJSON(tv.clientName); + obj["clientBackend"] = toJSON(tv.clientBackend); + } + break; + } + return obj; + } + JToken toJSON(Frame v) { + var obj = new JObject(); + switch (v.tag) { + case Frame.Tag.Frame: + obj["tag"] = "Frame"; + { + var tv = (data.Frame)v; + obj["renderCount"] = toJSON(tv.renderCount); + obj["frameUniforms"] = toJSON(tv.frameUniforms); + obj["frameTextures"] = toJSON(tv.frameTextures); + } + break; + } + return obj; + } + JToken toJSON(Scene v) { + var obj = new JObject(); + switch (v.tag) { + case Scene.Tag.Scene: + obj["tag"] = "Scene"; + { + var tv = (data.Scene)v; + obj["objectArrays"] = toJSON(tv.objectArrays); + obj["renderTargetWidth"] = toJSON(tv.renderTargetWidth); + obj["renderTargetHeight"] = toJSON(tv.renderTargetHeight); + obj["frames"] = toJSON(tv.frames); + } + break; + } + return obj; + } + JToken toJSON(PipelineInfo v) { + var obj = new JObject(); + switch (v.tag) { + case PipelineInfo.Tag.PipelineInfo: + obj["tag"] = "PipelineInfo"; + { + var tv = (data.PipelineInfo)v; + obj["pipelineName"] = toJSON(tv.pipelineName); + obj["pipeline"] = toJSON(tv.pipeline); + } + break; + } + return obj; + } + JToken toJSON(RenderJob v) { + var obj = new JObject(); + switch (v.tag) { + case RenderJob.Tag.RenderJob: + obj["tag"] = "RenderJob"; + { + var tv = (data.RenderJob)v; + obj["meshes"] = toJSON(tv.meshes); + obj["textures"] = toJSON(tv.textures); + obj["schema"] = toJSON(tv.schema); + obj["scenes"] = toJSON(tv.scenes); + obj["pipelines"] = toJSON(tv.pipelines); + } + break; + } + return obj; + } + JToken toJSON(FrameResult v) { + var obj = new JObject(); + switch (v.tag) { + case FrameResult.Tag.FrameResult: + obj["tag"] = "FrameResult"; + { + var tv = (data.FrameResult)v; + obj["frRenderTimes"] = toJSON(tv.frRenderTimes); + obj["frImageWidth"] = toJSON(tv.frImageWidth); + obj["frImageHeight"] = toJSON(tv.frImageHeight); + } + break; + } + return obj; + } + JToken toJSON(RenderJobResult v) { + var obj = new JObject(); + switch (v.tag) { + case RenderJobResult.Tag.RenderJobResult: + obj["tag"] = "RenderJobResult"; + { + var tv = (data.RenderJobResult)v; + obj["arg0"] = toJSON(tv._0); + } + break; + case RenderJobResult.Tag.RenderJobError: + obj["tag"] = "RenderJobError"; + { + var tv = (data.RenderJobError)v; + obj["arg0"] = toJSON(tv._0); + } + break; + } + return obj; + } + + JToken toJSON(int v) { return new JValue(v); } + JToken toJSON(float v) { return new JValue(v); } + JToken toJSON(string v) { return new JValue(v); } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(List v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + JToken toJSON(Dictionary> v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + JToken toJSON(Dictionary v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + } +} diff --git a/ddl/out/TestData.hpp b/ddl/out/TestData.hpp index bf90d88..00cdfda 100644 --- a/ddl/out/TestData.hpp +++ b/ddl/out/TestData.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.829757000000Z +======= +// 2016-03-20T21:42:13.043021000000Z +>>>>>>> working c# backend #ifndef HEADER_TestData_H #define HEADER_TestData_H diff --git a/ddl/out/TestData.hs b/ddl/out/TestData.hs index 489e3c3..60f8ff9 100644 --- a/ddl/out/TestData.hs +++ b/ddl/out/TestData.hs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.829757000000Z +======= +-- 2016-03-20T21:42:13.043021000000Z +>>>>>>> working c# backend {-# LANGUAGE OverloadedStrings, RecordWildCards #-} module TestData where diff --git a/ddl/out/TestData.java b/ddl/out/TestData.java new file mode 100644 index 0000000..aa6b656 --- /dev/null +++ b/ddl/out/TestData.java @@ -0,0 +1,103 @@ +// generated file, do not modify! +// 2016-03-14T10:58:30.042864000000Z + +import LambdaCube.IR; +import LambdaCube.Mesh; +import LambdaCube.PipelineSchema; + +public class TestData { + public class ClientInfo { + public enum Tag { + ClientInfo + } + public Tag tag; + + public class ClientInfo extends ClientInfo { + public String clientName; + public Backend clientBackend; + } + } + + public class Frame { + public enum Tag { + Frame + } + public Tag tag; + + public class Frame extends Frame { + public Integer renderCount; + public HashMap frameUniforms; + public HashMap frameTextures; + } + } + + public class Scene { + public enum Tag { + Scene + } + public Tag tag; + + public class Scene extends Scene { + public HashMap> objectArrays; + public Integer renderTargetWidth; + public Integer renderTargetHeight; + public ArrayList frames; + } + } + + public class PipelineInfo { + public enum Tag { + PipelineInfo + } + public Tag tag; + + public class PipelineInfo extends PipelineInfo { + public String pipelineName; + public Pipeline pipeline; + } + } + + public class RenderJob { + public enum Tag { + RenderJob + } + public Tag tag; + + public class RenderJob extends RenderJob { + public ArrayList meshes; + public ArrayList textures; + public PipelineSchema schema; + public ArrayList scenes; + public ArrayList pipelines; + } + } + + public class FrameResult { + public enum Tag { + FrameResult + } + public Tag tag; + + public class FrameResult extends FrameResult { + public ArrayList frRenderTimes; + public Integer frImageWidth; + public Integer frImageHeight; + } + } + + public class RenderJobResult { + public enum Tag { + RenderJobResult, + RenderJobError + } + public Tag tag; + + public class RenderJobResult extends RenderJobResult { + public FrameResult _0; + } + public class RenderJobError extends RenderJobResult { + public String _0; + } + } + +} \ No newline at end of file diff --git a/ddl/out/TestData.purs b/ddl/out/TestData.purs index e4da3b2..47f46ca 100644 --- a/ddl/out/TestData.purs +++ b/ddl/out/TestData.purs @@ -1,5 +1,9 @@ -- generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 -- 2016-03-01T13:00:40.829757000000Z +======= +-- 2016-03-20T21:42:13.043021000000Z +>>>>>>> working c# backend module TestData where import Prelude diff --git a/ddl/out/TestData.swift b/ddl/out/TestData.swift index adb9e25..6e31913 100644 --- a/ddl/out/TestData.swift +++ b/ddl/out/TestData.swift @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.829757000000Z +======= +// 2016-03-20T21:42:13.043021000000Z +>>>>>>> working c# backend enum ClientInfo { case ClientInfo(ClientInfo_Data) diff --git a/ddl/out/TestData2.hpp b/ddl/out/TestData2.hpp index 49ac46e..a88050a 100644 --- a/ddl/out/TestData2.hpp +++ b/ddl/out/TestData2.hpp @@ -1,5 +1,9 @@ // generated file, do not modify! +<<<<<<< 3b50722f433ec5ecc515ea1441fd633d85118cb9 // 2016-03-01T13:00:40.829757000000Z +======= +// 2016-03-20T21:42:13.043021000000Z +>>>>>>> working c# backend #ifndef HEADER_TestData_H #define HEADER_TestData_H diff --git a/ddl/out/java/LambdaCube/IR/AccumulationContext.java b/ddl/out/java/LambdaCube/IR/AccumulationContext.java new file mode 100644 index 0000000..a190597 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/AccumulationContext.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class AccumulationContext { + public enum Tag { + AccumulationContext + } + public Tag tag; + + public class AccumulationContext_ extends AccumulationContext { + public Maybe accViewportName; + public ArrayList accOperations; + public AccumulationContext_() { tag = AccumulationContext.Tag.AccumulationContext; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/ArrayValue.java b/ddl/out/java/LambdaCube/IR/ArrayValue.java new file mode 100644 index 0000000..b176300 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ArrayValue.java @@ -0,0 +1,37 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ArrayValue { + public enum Tag { + VBoolArray, + VIntArray, + VWordArray, + VFloatArray + } + public Tag tag; + + public class VBoolArray_ extends ArrayValue { + public ArrayList _0; + public VBoolArray_() { tag = ArrayValue.Tag.VBoolArray; } + } + public class VIntArray_ extends ArrayValue { + public ArrayList _0; + public VIntArray_() { tag = ArrayValue.Tag.VIntArray; } + } + public class VWordArray_ extends ArrayValue { + public ArrayList _0; + public VWordArray_() { tag = ArrayValue.Tag.VWordArray; } + } + public class VFloatArray_ extends ArrayValue { + public ArrayList _0; + public VFloatArray_() { tag = ArrayValue.Tag.VFloatArray; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/Backend.java b/ddl/out/java/LambdaCube/IR/Backend.java new file mode 100644 index 0000000..bbe74b8 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Backend.java @@ -0,0 +1,19 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Backend { + public enum Tag { + WebGL1, + OpenGL33 + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/BlendEquation.java b/ddl/out/java/LambdaCube/IR/BlendEquation.java new file mode 100644 index 0000000..6dd1523 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/BlendEquation.java @@ -0,0 +1,22 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class BlendEquation { + public enum Tag { + FuncAdd, + FuncSubtract, + FuncReverseSubtract, + Min, + Max + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/Blending.java b/ddl/out/java/LambdaCube/IR/Blending.java new file mode 100644 index 0000000..331ae4e --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Blending.java @@ -0,0 +1,34 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Blending { + public enum Tag { + NoBlending, + BlendLogicOp, + Blend + } + public Tag tag; + + public class BlendLogicOp_ extends Blending { + public LogicOperation _0; + public BlendLogicOp_() { tag = Blending.Tag.BlendLogicOp; } + } + public class Blend_ extends Blending { + public BlendEquation colorEqSrc; + public BlendEquation alphaEqSrc; + public BlendingFactor colorFSrc; + public BlendingFactor colorFDst; + public BlendingFactor alphaFSrc; + public BlendingFactor alphaFDst; + public V4 color; + public Blend_() { tag = Blending.Tag.Blend; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/BlendingFactor.java b/ddl/out/java/LambdaCube/IR/BlendingFactor.java new file mode 100644 index 0000000..fe73075 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/BlendingFactor.java @@ -0,0 +1,32 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class BlendingFactor { + public enum Tag { + Zero, + One, + SrcColor, + OneMinusSrcColor, + DstColor, + OneMinusDstColor, + SrcAlpha, + OneMinusSrcAlpha, + DstAlpha, + OneMinusDstAlpha, + ConstantColor, + OneMinusConstantColor, + ConstantAlpha, + OneMinusConstantAlpha, + SrcAlphaSaturate + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/ClearImage.java b/ddl/out/java/LambdaCube/IR/ClearImage.java new file mode 100644 index 0000000..64491e9 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ClearImage.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ClearImage { + public enum Tag { + ClearImage + } + public Tag tag; + + public class ClearImage_ extends ClearImage { + public ImageSemantic imageSemantic; + public Value clearValue; + public ClearImage_() { tag = ClearImage.Tag.ClearImage; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/ColorArity.java b/ddl/out/java/LambdaCube/IR/ColorArity.java new file mode 100644 index 0000000..77ba1a0 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ColorArity.java @@ -0,0 +1,21 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ColorArity { + public enum Tag { + Red, + RG, + RGB, + RGBA + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/Command.java b/ddl/out/java/LambdaCube/IR/Command.java new file mode 100644 index 0000000..90ec2c5 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Command.java @@ -0,0 +1,87 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Command { + public enum Tag { + SetRasterContext, + SetAccumulationContext, + SetRenderTarget, + SetProgram, + SetSamplerUniform, + SetTexture, + SetSampler, + RenderSlot, + RenderStream, + ClearRenderTarget, + GenerateMipMap, + SaveImage, + LoadImage + } + public Tag tag; + + public class SetRasterContext_ extends Command { + public RasterContext _0; + public SetRasterContext_() { tag = Command.Tag.SetRasterContext; } + } + public class SetAccumulationContext_ extends Command { + public AccumulationContext _0; + public SetAccumulationContext_() { tag = Command.Tag.SetAccumulationContext; } + } + public class SetRenderTarget_ extends Command { + public Integer _0; + public SetRenderTarget_() { tag = Command.Tag.SetRenderTarget; } + } + public class SetProgram_ extends Command { + public Integer _0; + public SetProgram_() { tag = Command.Tag.SetProgram; } + } + public class SetSamplerUniform_ extends Command { + public String _0; + public Integer _1; + public SetSamplerUniform_() { tag = Command.Tag.SetSamplerUniform; } + } + public class SetTexture_ extends Command { + public Integer _0; + public Integer _1; + public SetTexture_() { tag = Command.Tag.SetTexture; } + } + public class SetSampler_ extends Command { + public Integer _0; + public Maybe _1; + public SetSampler_() { tag = Command.Tag.SetSampler; } + } + public class RenderSlot_ extends Command { + public Integer _0; + public RenderSlot_() { tag = Command.Tag.RenderSlot; } + } + public class RenderStream_ extends Command { + public Integer _0; + public RenderStream_() { tag = Command.Tag.RenderStream; } + } + public class ClearRenderTarget_ extends Command { + public ArrayList _0; + public ClearRenderTarget_() { tag = Command.Tag.ClearRenderTarget; } + } + public class GenerateMipMap_ extends Command { + public Integer _0; + public GenerateMipMap_() { tag = Command.Tag.GenerateMipMap; } + } + public class SaveImage_ extends Command { + public Integer _0; + public ImageRef _1; + public SaveImage_() { tag = Command.Tag.SaveImage; } + } + public class LoadImage_ extends Command { + public ImageRef _0; + public Integer _1; + public LoadImage_() { tag = Command.Tag.LoadImage; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/ComparisonFunction.java b/ddl/out/java/LambdaCube/IR/ComparisonFunction.java new file mode 100644 index 0000000..d3c5112 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ComparisonFunction.java @@ -0,0 +1,25 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ComparisonFunction { + public enum Tag { + Never, + Less, + Equal, + Lequal, + Greater, + Notequal, + Gequal, + Always + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/CullMode.java b/ddl/out/java/LambdaCube/IR/CullMode.java new file mode 100644 index 0000000..f2ce3a8 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/CullMode.java @@ -0,0 +1,28 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class CullMode { + public enum Tag { + CullNone, + CullFront, + CullBack + } + public Tag tag; + + public class CullFront_ extends CullMode { + public FrontFace _0; + public CullFront_() { tag = CullMode.Tag.CullFront; } + } + public class CullBack_ extends CullMode { + public FrontFace _0; + public CullBack_() { tag = CullMode.Tag.CullBack; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/EdgeMode.java b/ddl/out/java/LambdaCube/IR/EdgeMode.java new file mode 100644 index 0000000..19a8eba --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/EdgeMode.java @@ -0,0 +1,21 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class EdgeMode { + public enum Tag { + Repeat, + MirroredRepeat, + ClampToEdge, + ClampToBorder + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/FetchPrimitive.java b/ddl/out/java/LambdaCube/IR/FetchPrimitive.java new file mode 100644 index 0000000..16453bc --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/FetchPrimitive.java @@ -0,0 +1,22 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class FetchPrimitive { + public enum Tag { + Points, + Lines, + Triangles, + LinesAdjacency, + TrianglesAdjacency + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/Filter.java b/ddl/out/java/LambdaCube/IR/Filter.java new file mode 100644 index 0000000..4bd3b7c --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Filter.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Filter { + public enum Tag { + Nearest, + Linear, + NearestMipmapNearest, + NearestMipmapLinear, + LinearMipmapNearest, + LinearMipmapLinear + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/FragmentOperation.java b/ddl/out/java/LambdaCube/IR/FragmentOperation.java new file mode 100644 index 0000000..35aa5a9 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/FragmentOperation.java @@ -0,0 +1,36 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class FragmentOperation { + public enum Tag { + DepthOp, + StencilOp, + ColorOp + } + public Tag tag; + + public class DepthOp_ extends FragmentOperation { + public ComparisonFunction _0; + public Boolean _1; + public DepthOp_() { tag = FragmentOperation.Tag.DepthOp; } + } + public class StencilOp_ extends FragmentOperation { + public StencilTests _0; + public StencilOps _1; + public StencilOps _2; + public StencilOp_() { tag = FragmentOperation.Tag.StencilOp; } + } + public class ColorOp_ extends FragmentOperation { + public Blending _0; + public Value _1; + public ColorOp_() { tag = FragmentOperation.Tag.ColorOp; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/FrontFace.java b/ddl/out/java/LambdaCube/IR/FrontFace.java new file mode 100644 index 0000000..dff345f --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/FrontFace.java @@ -0,0 +1,19 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class FrontFace { + public enum Tag { + CCW, + CW + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/ImageRef.java b/ddl/out/java/LambdaCube/IR/ImageRef.java new file mode 100644 index 0000000..51385dc --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ImageRef.java @@ -0,0 +1,29 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ImageRef { + public enum Tag { + TextureImage, + Framebuffer + } + public Tag tag; + + public class TextureImage_ extends ImageRef { + public Integer _0; + public Integer _1; + public Maybe _2; + public TextureImage_() { tag = ImageRef.Tag.TextureImage; } + } + public class Framebuffer_ extends ImageRef { + public ImageSemantic _0; + public Framebuffer_() { tag = ImageRef.Tag.Framebuffer; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/ImageSemantic.java b/ddl/out/java/LambdaCube/IR/ImageSemantic.java new file mode 100644 index 0000000..22aea08 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ImageSemantic.java @@ -0,0 +1,20 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ImageSemantic { + public enum Tag { + Depth, + Stencil, + Color + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/InputType.java b/ddl/out/java/LambdaCube/IR/InputType.java new file mode 100644 index 0000000..f8764d1 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/InputType.java @@ -0,0 +1,78 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class InputType { + public enum 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 + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/JSON.java b/ddl/out/java/LambdaCube/IR/JSON.java new file mode 100644 index 0000000..3515e25 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/JSON.java @@ -0,0 +1,1460 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import org.json.*; +import RT.*; + + +public class JSON { + // JSON deserializer + public enum Type { + Int, + Int32, + Word, + Word32, + Float, + Bool, + String, + V2_Int, + V2_Word, + V2_Float, + V2_Bool, + V2_V2_Float, + V2_V3_Float, + V2_V4_Float, + V3_Int, + V3_Word, + V3_Float, + V3_Bool, + V3_V2_Float, + V3_V3_Float, + V3_V4_Float, + V4_Int, + V4_Word, + V4_Float, + V4_Bool, + V4_V2_Float, + V4_V3_Float, + V4_V4_Float, + Array_Int, + Array_Int32, + Array_Word32, + Array_Float, + Array_Bool, + Array_ClearImage, + Array_Command, + Array_Parameter, + Array_Program, + Array_RenderTarget, + Array_SamplerDescriptor, + Array_Slot, + Array_StreamData, + Array_TargetItem, + Array_TextureDescriptor, + List_FragmentOperation, + Maybe_Int, + Maybe_Float, + Maybe_String, + Maybe_ComparisonFunction, + Maybe_EdgeMode, + Maybe_ImageRef, + Map_String_ArrayValue, + Map_String_InputType, + Map_String_Parameter, + AccumulationContext, + ArrayValue, + Backend, + BlendEquation, + Blending, + BlendingFactor, + ClearImage, + ColorArity, + Command, + ComparisonFunction, + CullMode, + EdgeMode, + FetchPrimitive, + Filter, + FragmentOperation, + FrontFace, + ImageRef, + ImageSemantic, + InputType, + LogicOperation, + MipMap, + OutputPrimitive, + Parameter, + Pipeline, + PointSize, + PointSpriteCoordOrigin, + PolygonMode, + PolygonOffset, + Program, + ProvokingVertex, + RasterContext, + RenderTarget, + SamplerDescriptor, + Slot, + StencilOperation, + StencilOps, + StencilTest, + StencilTests, + StreamData, + TargetItem, + TextureDataType, + TextureDescriptor, + TextureType, + Value + } + + public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception { + switch (type) { + case Int: return (Integer)rawObj; + case Int32: return (Integer)rawObj; + case Word: return (Integer)rawObj; + case Word32: return (Integer)rawObj; + case Float: return (Float)rawObj; + case Bool: return (Boolean)rawObj; + case String: return (String)rawObj; + case V2_Int: { + JSONObject obj = (JSONObject)rawObj; + return new V2 + ( (Integer)fromJSON(Type.Int,obj.get("x")) + , (Integer)fromJSON(Type.Int,obj.get("y")) + ); + } + case V2_Word: { + JSONObject obj = (JSONObject)rawObj; + return new V2 + ( (Integer)fromJSON(Type.Word,obj.get("x")) + , (Integer)fromJSON(Type.Word,obj.get("y")) + ); + } + case V2_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V2 + ( (Float)fromJSON(Type.Float,obj.get("x")) + , (Float)fromJSON(Type.Float,obj.get("y")) + ); + } + case V2_Bool: { + JSONObject obj = (JSONObject)rawObj; + return new V2 + ( (Boolean)fromJSON(Type.Bool,obj.get("x")) + , (Boolean)fromJSON(Type.Bool,obj.get("y")) + ); + } + case V2_V2_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V2> + ( (V2)fromJSON(Type.V2_Float,obj.get("x")) + , (V2)fromJSON(Type.V2_Float,obj.get("y")) + ); + } + case V2_V3_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V2> + ( (V3)fromJSON(Type.V3_Float,obj.get("x")) + , (V3)fromJSON(Type.V3_Float,obj.get("y")) + ); + } + case V2_V4_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V2> + ( (V4)fromJSON(Type.V4_Float,obj.get("x")) + , (V4)fromJSON(Type.V4_Float,obj.get("y")) + ); + } + case V3_Int: { + JSONObject obj = (JSONObject)rawObj; + return new V3 + ( (Integer)fromJSON(Type.Int,obj.get("x")) + , (Integer)fromJSON(Type.Int,obj.get("y")) + , (Integer)fromJSON(Type.Int,obj.get("z")) + ); + } + case V3_Word: { + JSONObject obj = (JSONObject)rawObj; + return new V3 + ( (Integer)fromJSON(Type.Word,obj.get("x")) + , (Integer)fromJSON(Type.Word,obj.get("y")) + , (Integer)fromJSON(Type.Word,obj.get("z")) + ); + } + case V3_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V3 + ( (Float)fromJSON(Type.Float,obj.get("x")) + , (Float)fromJSON(Type.Float,obj.get("y")) + , (Float)fromJSON(Type.Float,obj.get("z")) + ); + } + case V3_Bool: { + JSONObject obj = (JSONObject)rawObj; + return new V3 + ( (Boolean)fromJSON(Type.Bool,obj.get("x")) + , (Boolean)fromJSON(Type.Bool,obj.get("y")) + , (Boolean)fromJSON(Type.Bool,obj.get("z")) + ); + } + case V3_V2_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V3> + ( (V2)fromJSON(Type.V2_Float,obj.get("x")) + , (V2)fromJSON(Type.V2_Float,obj.get("y")) + , (V2)fromJSON(Type.V2_Float,obj.get("z")) + ); + } + case V3_V3_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V3> + ( (V3)fromJSON(Type.V3_Float,obj.get("x")) + , (V3)fromJSON(Type.V3_Float,obj.get("y")) + , (V3)fromJSON(Type.V3_Float,obj.get("z")) + ); + } + case V3_V4_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V3> + ( (V4)fromJSON(Type.V4_Float,obj.get("x")) + , (V4)fromJSON(Type.V4_Float,obj.get("y")) + , (V4)fromJSON(Type.V4_Float,obj.get("z")) + ); + } + case V4_Int: { + JSONObject obj = (JSONObject)rawObj; + return new V4 + ( (Integer)fromJSON(Type.Int,obj.get("x")) + , (Integer)fromJSON(Type.Int,obj.get("y")) + , (Integer)fromJSON(Type.Int,obj.get("z")) + , (Integer)fromJSON(Type.Int,obj.get("w")) + ); + } + case V4_Word: { + JSONObject obj = (JSONObject)rawObj; + return new V4 + ( (Integer)fromJSON(Type.Word,obj.get("x")) + , (Integer)fromJSON(Type.Word,obj.get("y")) + , (Integer)fromJSON(Type.Word,obj.get("z")) + , (Integer)fromJSON(Type.Word,obj.get("w")) + ); + } + case V4_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V4 + ( (Float)fromJSON(Type.Float,obj.get("x")) + , (Float)fromJSON(Type.Float,obj.get("y")) + , (Float)fromJSON(Type.Float,obj.get("z")) + , (Float)fromJSON(Type.Float,obj.get("w")) + ); + } + case V4_Bool: { + JSONObject obj = (JSONObject)rawObj; + return new V4 + ( (Boolean)fromJSON(Type.Bool,obj.get("x")) + , (Boolean)fromJSON(Type.Bool,obj.get("y")) + , (Boolean)fromJSON(Type.Bool,obj.get("z")) + , (Boolean)fromJSON(Type.Bool,obj.get("w")) + ); + } + case V4_V2_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V4> + ( (V2)fromJSON(Type.V2_Float,obj.get("x")) + , (V2)fromJSON(Type.V2_Float,obj.get("y")) + , (V2)fromJSON(Type.V2_Float,obj.get("z")) + , (V2)fromJSON(Type.V2_Float,obj.get("w")) + ); + } + case V4_V3_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V4> + ( (V3)fromJSON(Type.V3_Float,obj.get("x")) + , (V3)fromJSON(Type.V3_Float,obj.get("y")) + , (V3)fromJSON(Type.V3_Float,obj.get("z")) + , (V3)fromJSON(Type.V3_Float,obj.get("w")) + ); + } + case V4_V4_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V4> + ( (V4)fromJSON(Type.V4_Float,obj.get("x")) + , (V4)fromJSON(Type.V4_Float,obj.get("y")) + , (V4)fromJSON(Type.V4_Float,obj.get("z")) + , (V4)fromJSON(Type.V4_Float,obj.get("w")) + ); + } +// case Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList(); +// case Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList(); +// case Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList(); +// case Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList(); +// case Array_Bool: return ((JArray)obj).Select(x => fromJSON (Type.Bool, x)).ToList(); +// case Array_ClearImage: return ((JArray)obj).Select(x => fromJSON (Type.ClearImage, x)).ToList(); +// case Array_Command: return ((JArray)obj).Select(x => fromJSON (Type.Command, x)).ToList(); +// case Array_Parameter: return ((JArray)obj).Select(x => fromJSON (Type.Parameter, x)).ToList(); +// case Array_Program: return ((JArray)obj).Select(x => fromJSON (Type.Program, x)).ToList(); +// case Array_RenderTarget: return ((JArray)obj).Select(x => fromJSON (Type.RenderTarget, x)).ToList(); +// case Array_SamplerDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.SamplerDescriptor, x)).ToList(); +// case Array_Slot: return ((JArray)obj).Select(x => fromJSON (Type.Slot, x)).ToList(); +// case Array_StreamData: return ((JArray)obj).Select(x => fromJSON (Type.StreamData, x)).ToList(); +// case Array_TargetItem: return ((JArray)obj).Select(x => fromJSON (Type.TargetItem, x)).ToList(); +// case Array_TextureDescriptor: return ((JArray)obj).Select(x => fromJSON (Type.TextureDescriptor, x)).ToList(); +// case List_FragmentOperation: return ((JArray)obj).Select(x => fromJSON (Type.FragmentOperation, x)).ToList(); +/* + case Maybe_Int: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (Integer)fromJSON (Type.Int,obj); + } + return m; + } +*/ +/* + case Maybe_Float: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (Float)fromJSON (Type.Float,obj); + } + return m; + } +*/ +/* + case Maybe_String: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (String)fromJSON (Type.String,obj); + } + return m; + } +*/ +/* + case Maybe_ComparisonFunction: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (ComparisonFunction)fromJSON (Type.ComparisonFunction,obj); + } + return m; + } +*/ +/* + case Maybe_EdgeMode: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (EdgeMode)fromJSON (Type.EdgeMode,obj); + } + return m; + } +*/ +/* + case Maybe_ImageRef: { + var m = new Maybe (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = (ImageRef)fromJSON (Type.ImageRef,obj); + } + return m; + } +*/ +/* + case Map_String_ArrayValue: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (ArrayValue)fromJSON(Type.ArrayValue,i.Value)); + } + return map; + } +*/ +/* + case Map_String_InputType: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (InputType)fromJSON(Type.InputType,i.Value)); + } + return map; + } +*/ +/* + case Map_String_Parameter: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (Parameter)fromJSON(Type.Parameter,i.Value)); + } + return map; + } +*/ + + case ArrayValue: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "VBoolArray": { + ArrayValue.VBoolArray_ tv = new ArrayValue().new VBoolArray_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Bool,obj.get("arg0")); + return tv; + } + case "VIntArray": { + ArrayValue.VIntArray_ tv = new ArrayValue().new VIntArray_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Int32,obj.get("arg0")); + return tv; + } + case "VWordArray": { + ArrayValue.VWordArray_ tv = new ArrayValue().new VWordArray_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Word32,obj.get("arg0")); + return tv; + } + case "VFloatArray": { + ArrayValue.VFloatArray_ tv = new ArrayValue().new VFloatArray_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Float,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Value: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "VBool": { + Value.VBool_ tv = new Value().new VBool_(); + tv._0 = (Boolean)fromJSON(Type.Bool,obj.get("arg0")); + return tv; + } + case "VV2B": { + Value.VV2B_ tv = new Value().new VV2B_(); + tv._0 = (V2)fromJSON(Type.V2_Bool,obj.get("arg0")); + return tv; + } + case "VV3B": { + Value.VV3B_ tv = new Value().new VV3B_(); + tv._0 = (V3)fromJSON(Type.V3_Bool,obj.get("arg0")); + return tv; + } + case "VV4B": { + Value.VV4B_ tv = new Value().new VV4B_(); + tv._0 = (V4)fromJSON(Type.V4_Bool,obj.get("arg0")); + return tv; + } + case "VWord": { + Value.VWord_ tv = new Value().new VWord_(); + tv._0 = (Integer)fromJSON(Type.Word32,obj.get("arg0")); + return tv; + } + case "VV2U": { + Value.VV2U_ tv = new Value().new VV2U_(); + tv._0 = (V2)fromJSON(Type.V2_Word,obj.get("arg0")); + return tv; + } + case "VV3U": { + Value.VV3U_ tv = new Value().new VV3U_(); + tv._0 = (V3)fromJSON(Type.V3_Word,obj.get("arg0")); + return tv; + } + case "VV4U": { + Value.VV4U_ tv = new Value().new VV4U_(); + tv._0 = (V4)fromJSON(Type.V4_Word,obj.get("arg0")); + return tv; + } + case "VInt": { + Value.VInt_ tv = new Value().new VInt_(); + tv._0 = (Integer)fromJSON(Type.Int32,obj.get("arg0")); + return tv; + } + case "VV2I": { + Value.VV2I_ tv = new Value().new VV2I_(); + tv._0 = (V2)fromJSON(Type.V2_Int,obj.get("arg0")); + return tv; + } + case "VV3I": { + Value.VV3I_ tv = new Value().new VV3I_(); + tv._0 = (V3)fromJSON(Type.V3_Int,obj.get("arg0")); + return tv; + } + case "VV4I": { + Value.VV4I_ tv = new Value().new VV4I_(); + tv._0 = (V4)fromJSON(Type.V4_Int,obj.get("arg0")); + return tv; + } + case "VFloat": { + Value.VFloat_ tv = new Value().new VFloat_(); + tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0")); + return tv; + } + case "VV2F": { + Value.VV2F_ tv = new Value().new VV2F_(); + tv._0 = (V2)fromJSON(Type.V2_Float,obj.get("arg0")); + return tv; + } + case "VV3F": { + Value.VV3F_ tv = new Value().new VV3F_(); + tv._0 = (V3)fromJSON(Type.V3_Float,obj.get("arg0")); + return tv; + } + case "VV4F": { + Value.VV4F_ tv = new Value().new VV4F_(); + tv._0 = (V4)fromJSON(Type.V4_Float,obj.get("arg0")); + return tv; + } + case "VM22F": { + Value.VM22F_ tv = new Value().new VM22F_(); + tv._0 = (V2>)fromJSON(Type.V2_V2_Float,obj.get("arg0")); + return tv; + } + case "VM23F": { + Value.VM23F_ tv = new Value().new VM23F_(); + tv._0 = (V3>)fromJSON(Type.V3_V2_Float,obj.get("arg0")); + return tv; + } + case "VM24F": { + Value.VM24F_ tv = new Value().new VM24F_(); + tv._0 = (V4>)fromJSON(Type.V4_V2_Float,obj.get("arg0")); + return tv; + } + case "VM32F": { + Value.VM32F_ tv = new Value().new VM32F_(); + tv._0 = (V2>)fromJSON(Type.V2_V3_Float,obj.get("arg0")); + return tv; + } + case "VM33F": { + Value.VM33F_ tv = new Value().new VM33F_(); + tv._0 = (V3>)fromJSON(Type.V3_V3_Float,obj.get("arg0")); + return tv; + } + case "VM34F": { + Value.VM34F_ tv = new Value().new VM34F_(); + tv._0 = (V4>)fromJSON(Type.V4_V3_Float,obj.get("arg0")); + return tv; + } + case "VM42F": { + Value.VM42F_ tv = new Value().new VM42F_(); + tv._0 = (V2>)fromJSON(Type.V2_V4_Float,obj.get("arg0")); + return tv; + } + case "VM43F": { + Value.VM43F_ tv = new Value().new VM43F_(); + tv._0 = (V3>)fromJSON(Type.V3_V4_Float,obj.get("arg0")); + return tv; + } + case "VM44F": { + Value.VM44F_ tv = new Value().new VM44F_(); + tv._0 = (V4>)fromJSON(Type.V4_V4_Float,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case InputType: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + InputType.Tag tagType; + switch (tag) { + case "Bool": tagType = InputType.Tag.Bool; break; + case "V2B": tagType = InputType.Tag.V2B; break; + case "V3B": tagType = InputType.Tag.V3B; break; + case "V4B": tagType = InputType.Tag.V4B; break; + case "Word": tagType = InputType.Tag.Word; break; + case "V2U": tagType = InputType.Tag.V2U; break; + case "V3U": tagType = InputType.Tag.V3U; break; + case "V4U": tagType = InputType.Tag.V4U; break; + case "Int": tagType = InputType.Tag.Int; break; + case "V2I": tagType = InputType.Tag.V2I; break; + case "V3I": tagType = InputType.Tag.V3I; break; + case "V4I": tagType = InputType.Tag.V4I; break; + case "Float": tagType = InputType.Tag.Float; break; + case "V2F": tagType = InputType.Tag.V2F; break; + case "V3F": tagType = InputType.Tag.V3F; break; + case "V4F": tagType = InputType.Tag.V4F; break; + case "M22F": tagType = InputType.Tag.M22F; break; + case "M23F": tagType = InputType.Tag.M23F; break; + case "M24F": tagType = InputType.Tag.M24F; break; + case "M32F": tagType = InputType.Tag.M32F; break; + case "M33F": tagType = InputType.Tag.M33F; break; + case "M34F": tagType = InputType.Tag.M34F; break; + case "M42F": tagType = InputType.Tag.M42F; break; + case "M43F": tagType = InputType.Tag.M43F; break; + case "M44F": tagType = InputType.Tag.M44F; break; + case "STexture1D": tagType = InputType.Tag.STexture1D; break; + case "STexture2D": tagType = InputType.Tag.STexture2D; break; + case "STextureCube": tagType = InputType.Tag.STextureCube; break; + case "STexture1DArray": tagType = InputType.Tag.STexture1DArray; break; + case "STexture2DArray": tagType = InputType.Tag.STexture2DArray; break; + case "STexture2DRect": tagType = InputType.Tag.STexture2DRect; break; + case "FTexture1D": tagType = InputType.Tag.FTexture1D; break; + case "FTexture2D": tagType = InputType.Tag.FTexture2D; break; + case "FTexture3D": tagType = InputType.Tag.FTexture3D; break; + case "FTextureCube": tagType = InputType.Tag.FTextureCube; break; + case "FTexture1DArray": tagType = InputType.Tag.FTexture1DArray; break; + case "FTexture2DArray": tagType = InputType.Tag.FTexture2DArray; break; + case "FTexture2DMS": tagType = InputType.Tag.FTexture2DMS; break; + case "FTexture2DMSArray": tagType = InputType.Tag.FTexture2DMSArray; break; + case "FTextureBuffer": tagType = InputType.Tag.FTextureBuffer; break; + case "FTexture2DRect": tagType = InputType.Tag.FTexture2DRect; break; + case "ITexture1D": tagType = InputType.Tag.ITexture1D; break; + case "ITexture2D": tagType = InputType.Tag.ITexture2D; break; + case "ITexture3D": tagType = InputType.Tag.ITexture3D; break; + case "ITextureCube": tagType = InputType.Tag.ITextureCube; break; + case "ITexture1DArray": tagType = InputType.Tag.ITexture1DArray; break; + case "ITexture2DArray": tagType = InputType.Tag.ITexture2DArray; break; + case "ITexture2DMS": tagType = InputType.Tag.ITexture2DMS; break; + case "ITexture2DMSArray": tagType = InputType.Tag.ITexture2DMSArray; break; + case "ITextureBuffer": tagType = InputType.Tag.ITextureBuffer; break; + case "ITexture2DRect": tagType = InputType.Tag.ITexture2DRect; break; + case "UTexture1D": tagType = InputType.Tag.UTexture1D; break; + case "UTexture2D": tagType = InputType.Tag.UTexture2D; break; + case "UTexture3D": tagType = InputType.Tag.UTexture3D; break; + case "UTextureCube": tagType = InputType.Tag.UTextureCube; break; + case "UTexture1DArray": tagType = InputType.Tag.UTexture1DArray; break; + case "UTexture2DArray": tagType = InputType.Tag.UTexture2DArray; break; + case "UTexture2DMS": tagType = InputType.Tag.UTexture2DMS; break; + case "UTexture2DMSArray": tagType = InputType.Tag.UTexture2DMSArray; break; + case "UTextureBuffer": tagType = InputType.Tag.UTextureBuffer; break; + case "UTexture2DRect": tagType = InputType.Tag.UTexture2DRect; break; + default: throw new Exception("unknown constructor: " + tag); + } + InputType o = new InputType(); + o.tag = tagType; + return o; + } + case PointSpriteCoordOrigin: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + PointSpriteCoordOrigin.Tag tagType; + switch (tag) { + case "LowerLeft": tagType = PointSpriteCoordOrigin.Tag.LowerLeft; break; + case "UpperLeft": tagType = PointSpriteCoordOrigin.Tag.UpperLeft; break; + default: throw new Exception("unknown constructor: " + tag); + } + PointSpriteCoordOrigin o = new PointSpriteCoordOrigin(); + o.tag = tagType; + return o; + } + case PointSize: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + PointSize.Tag tagType; + switch (tag) { + case "PointSize": { + PointSize.PointSize_ tv = new PointSize().new PointSize_(); + tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0")); + return tv; + } + case "ProgramPointSize": tagType = PointSize.Tag.ProgramPointSize; break; + default: throw new Exception("unknown constructor: " + tag); + } + PointSize o = new PointSize(); + o.tag = tagType; + return o; + } + case PolygonOffset: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + PolygonOffset.Tag tagType; + switch (tag) { + case "NoOffset": tagType = PolygonOffset.Tag.NoOffset; break; + case "Offset": { + PolygonOffset.Offset_ tv = new PolygonOffset().new Offset_(); + tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0")); + tv._1 = (Float)fromJSON(Type.Float,obj.get("arg1")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + PolygonOffset o = new PolygonOffset(); + o.tag = tagType; + return o; + } + case FrontFace: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + FrontFace.Tag tagType; + switch (tag) { + case "CCW": tagType = FrontFace.Tag.CCW; break; + case "CW": tagType = FrontFace.Tag.CW; break; + default: throw new Exception("unknown constructor: " + tag); + } + FrontFace o = new FrontFace(); + o.tag = tagType; + return o; + } + case PolygonMode: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + PolygonMode.Tag tagType; + switch (tag) { + case "PolygonPoint": { + PolygonMode.PolygonPoint_ tv = new PolygonMode().new PolygonPoint_(); + tv._0 = (PointSize)fromJSON(Type.PointSize,obj.get("arg0")); + return tv; + } + case "PolygonLine": { + PolygonMode.PolygonLine_ tv = new PolygonMode().new PolygonLine_(); + tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0")); + return tv; + } + case "PolygonFill": tagType = PolygonMode.Tag.PolygonFill; break; + default: throw new Exception("unknown constructor: " + tag); + } + PolygonMode o = new PolygonMode(); + o.tag = tagType; + return o; + } + case ProvokingVertex: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + ProvokingVertex.Tag tagType; + switch (tag) { + case "FirstVertex": tagType = ProvokingVertex.Tag.FirstVertex; break; + case "LastVertex": tagType = ProvokingVertex.Tag.LastVertex; break; + default: throw new Exception("unknown constructor: " + tag); + } + ProvokingVertex o = new ProvokingVertex(); + o.tag = tagType; + return o; + } + case CullMode: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + CullMode.Tag tagType; + switch (tag) { + case "CullNone": tagType = CullMode.Tag.CullNone; break; + case "CullFront": { + CullMode.CullFront_ tv = new CullMode().new CullFront_(); + tv._0 = (FrontFace)fromJSON(Type.FrontFace,obj.get("arg0")); + return tv; + } + case "CullBack": { + CullMode.CullBack_ tv = new CullMode().new CullBack_(); + tv._0 = (FrontFace)fromJSON(Type.FrontFace,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + CullMode o = new CullMode(); + o.tag = tagType; + return o; + } + case ComparisonFunction: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + ComparisonFunction.Tag tagType; + switch (tag) { + case "Never": tagType = ComparisonFunction.Tag.Never; break; + case "Less": tagType = ComparisonFunction.Tag.Less; break; + case "Equal": tagType = ComparisonFunction.Tag.Equal; break; + case "Lequal": tagType = ComparisonFunction.Tag.Lequal; break; + case "Greater": tagType = ComparisonFunction.Tag.Greater; break; + case "Notequal": tagType = ComparisonFunction.Tag.Notequal; break; + case "Gequal": tagType = ComparisonFunction.Tag.Gequal; break; + case "Always": tagType = ComparisonFunction.Tag.Always; break; + default: throw new Exception("unknown constructor: " + tag); + } + ComparisonFunction o = new ComparisonFunction(); + o.tag = tagType; + return o; + } + case StencilOperation: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + StencilOperation.Tag tagType; + switch (tag) { + case "OpZero": tagType = StencilOperation.Tag.OpZero; break; + case "OpKeep": tagType = StencilOperation.Tag.OpKeep; break; + case "OpReplace": tagType = StencilOperation.Tag.OpReplace; break; + case "OpIncr": tagType = StencilOperation.Tag.OpIncr; break; + case "OpIncrWrap": tagType = StencilOperation.Tag.OpIncrWrap; break; + case "OpDecr": tagType = StencilOperation.Tag.OpDecr; break; + case "OpDecrWrap": tagType = StencilOperation.Tag.OpDecrWrap; break; + case "OpInvert": tagType = StencilOperation.Tag.OpInvert; break; + default: throw new Exception("unknown constructor: " + tag); + } + StencilOperation o = new StencilOperation(); + o.tag = tagType; + return o; + } + case BlendEquation: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + BlendEquation.Tag tagType; + switch (tag) { + case "FuncAdd": tagType = BlendEquation.Tag.FuncAdd; break; + case "FuncSubtract": tagType = BlendEquation.Tag.FuncSubtract; break; + case "FuncReverseSubtract": tagType = BlendEquation.Tag.FuncReverseSubtract; break; + case "Min": tagType = BlendEquation.Tag.Min; break; + case "Max": tagType = BlendEquation.Tag.Max; break; + default: throw new Exception("unknown constructor: " + tag); + } + BlendEquation o = new BlendEquation(); + o.tag = tagType; + return o; + } + case BlendingFactor: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + BlendingFactor.Tag tagType; + switch (tag) { + case "Zero": tagType = BlendingFactor.Tag.Zero; break; + case "One": tagType = BlendingFactor.Tag.One; break; + case "SrcColor": tagType = BlendingFactor.Tag.SrcColor; break; + case "OneMinusSrcColor": tagType = BlendingFactor.Tag.OneMinusSrcColor; break; + case "DstColor": tagType = BlendingFactor.Tag.DstColor; break; + case "OneMinusDstColor": tagType = BlendingFactor.Tag.OneMinusDstColor; break; + case "SrcAlpha": tagType = BlendingFactor.Tag.SrcAlpha; break; + case "OneMinusSrcAlpha": tagType = BlendingFactor.Tag.OneMinusSrcAlpha; break; + case "DstAlpha": tagType = BlendingFactor.Tag.DstAlpha; break; + case "OneMinusDstAlpha": tagType = BlendingFactor.Tag.OneMinusDstAlpha; break; + case "ConstantColor": tagType = BlendingFactor.Tag.ConstantColor; break; + case "OneMinusConstantColor": tagType = BlendingFactor.Tag.OneMinusConstantColor; break; + case "ConstantAlpha": tagType = BlendingFactor.Tag.ConstantAlpha; break; + case "OneMinusConstantAlpha": tagType = BlendingFactor.Tag.OneMinusConstantAlpha; break; + case "SrcAlphaSaturate": tagType = BlendingFactor.Tag.SrcAlphaSaturate; break; + default: throw new Exception("unknown constructor: " + tag); + } + BlendingFactor o = new BlendingFactor(); + o.tag = tagType; + return o; + } + case LogicOperation: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + LogicOperation.Tag tagType; + switch (tag) { + case "Clear": tagType = LogicOperation.Tag.Clear; break; + case "And": tagType = LogicOperation.Tag.And; break; + case "AndReverse": tagType = LogicOperation.Tag.AndReverse; break; + case "Copy": tagType = LogicOperation.Tag.Copy; break; + case "AndInverted": tagType = LogicOperation.Tag.AndInverted; break; + case "Noop": tagType = LogicOperation.Tag.Noop; break; + case "Xor": tagType = LogicOperation.Tag.Xor; break; + case "Or": tagType = LogicOperation.Tag.Or; break; + case "Nor": tagType = LogicOperation.Tag.Nor; break; + case "Equiv": tagType = LogicOperation.Tag.Equiv; break; + case "Invert": tagType = LogicOperation.Tag.Invert; break; + case "OrReverse": tagType = LogicOperation.Tag.OrReverse; break; + case "CopyInverted": tagType = LogicOperation.Tag.CopyInverted; break; + case "OrInverted": tagType = LogicOperation.Tag.OrInverted; break; + case "Nand": tagType = LogicOperation.Tag.Nand; break; + case "Set": tagType = LogicOperation.Tag.Set; break; + default: throw new Exception("unknown constructor: " + tag); + } + LogicOperation o = new LogicOperation(); + o.tag = tagType; + return o; + } + case StencilOps: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "StencilOps": { + StencilOps.StencilOps_ tv = new StencilOps().new StencilOps_(); + tv.frontStencilOp = (StencilOperation)fromJSON(Type.StencilOperation,obj.get("frontStencilOp")); + tv.backStencilOp = (StencilOperation)fromJSON(Type.StencilOperation,obj.get("backStencilOp")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case StencilTest: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "StencilTest": { + StencilTest.StencilTest_ tv = new StencilTest().new StencilTest_(); + tv.stencilComparision = (ComparisonFunction)fromJSON(Type.ComparisonFunction,obj.get("stencilComparision")); + tv.stencilReference = (Integer)fromJSON(Type.Int32,obj.get("stencilReference")); + tv.stencilMask = (Integer)fromJSON(Type.Word32,obj.get("stencilMask")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case StencilTests: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "StencilTests": { + StencilTests.StencilTests_ tv = new StencilTests().new StencilTests_(); + tv._0 = (StencilTest)fromJSON(Type.StencilTest,obj.get("arg0")); + tv._1 = (StencilTest)fromJSON(Type.StencilTest,obj.get("arg1")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case FetchPrimitive: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + FetchPrimitive.Tag tagType; + switch (tag) { + case "Points": tagType = FetchPrimitive.Tag.Points; break; + case "Lines": tagType = FetchPrimitive.Tag.Lines; break; + case "Triangles": tagType = FetchPrimitive.Tag.Triangles; break; + case "LinesAdjacency": tagType = FetchPrimitive.Tag.LinesAdjacency; break; + case "TrianglesAdjacency": tagType = FetchPrimitive.Tag.TrianglesAdjacency; break; + default: throw new Exception("unknown constructor: " + tag); + } + FetchPrimitive o = new FetchPrimitive(); + o.tag = tagType; + return o; + } + case OutputPrimitive: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + OutputPrimitive.Tag tagType; + switch (tag) { + case "TrianglesOutput": tagType = OutputPrimitive.Tag.TrianglesOutput; break; + case "LinesOutput": tagType = OutputPrimitive.Tag.LinesOutput; break; + case "PointsOutput": tagType = OutputPrimitive.Tag.PointsOutput; break; + default: throw new Exception("unknown constructor: " + tag); + } + OutputPrimitive o = new OutputPrimitive(); + o.tag = tagType; + return o; + } + case ColorArity: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + ColorArity.Tag tagType; + switch (tag) { + case "Red": tagType = ColorArity.Tag.Red; break; + case "RG": tagType = ColorArity.Tag.RG; break; + case "RGB": tagType = ColorArity.Tag.RGB; break; + case "RGBA": tagType = ColorArity.Tag.RGBA; break; + default: throw new Exception("unknown constructor: " + tag); + } + ColorArity o = new ColorArity(); + o.tag = tagType; + return o; + } + case Blending: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + Blending.Tag tagType; + switch (tag) { + case "NoBlending": tagType = Blending.Tag.NoBlending; break; + case "BlendLogicOp": { + Blending.BlendLogicOp_ tv = new Blending().new BlendLogicOp_(); + tv._0 = (LogicOperation)fromJSON(Type.LogicOperation,obj.get("arg0")); + return tv; + } + case "Blend": { + Blending.Blend_ tv = new Blending().new Blend_(); + tv.colorEqSrc = (BlendEquation)fromJSON(Type.BlendEquation,obj.get("colorEqSrc")); + tv.alphaEqSrc = (BlendEquation)fromJSON(Type.BlendEquation,obj.get("alphaEqSrc")); + tv.colorFSrc = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("colorFSrc")); + tv.colorFDst = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("colorFDst")); + tv.alphaFSrc = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("alphaFSrc")); + tv.alphaFDst = (BlendingFactor)fromJSON(Type.BlendingFactor,obj.get("alphaFDst")); + tv.color = (V4)fromJSON(Type.V4_Float,obj.get("color")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + Blending o = new Blending(); + o.tag = tagType; + return o; + } + case RasterContext: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "PointCtx": { + RasterContext.PointCtx_ tv = new RasterContext().new PointCtx_(); + tv._0 = (PointSize)fromJSON(Type.PointSize,obj.get("arg0")); + tv._1 = (Float)fromJSON(Type.Float,obj.get("arg1")); + tv._2 = (PointSpriteCoordOrigin)fromJSON(Type.PointSpriteCoordOrigin,obj.get("arg2")); + return tv; + } + case "LineCtx": { + RasterContext.LineCtx_ tv = new RasterContext().new LineCtx_(); + tv._0 = (Float)fromJSON(Type.Float,obj.get("arg0")); + tv._1 = (ProvokingVertex)fromJSON(Type.ProvokingVertex,obj.get("arg1")); + return tv; + } + case "TriangleCtx": { + RasterContext.TriangleCtx_ tv = new RasterContext().new TriangleCtx_(); + tv._0 = (CullMode)fromJSON(Type.CullMode,obj.get("arg0")); + tv._1 = (PolygonMode)fromJSON(Type.PolygonMode,obj.get("arg1")); + tv._2 = (PolygonOffset)fromJSON(Type.PolygonOffset,obj.get("arg2")); + tv._3 = (ProvokingVertex)fromJSON(Type.ProvokingVertex,obj.get("arg3")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case FragmentOperation: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "DepthOp": { + FragmentOperation.DepthOp_ tv = new FragmentOperation().new DepthOp_(); + tv._0 = (ComparisonFunction)fromJSON(Type.ComparisonFunction,obj.get("arg0")); + tv._1 = (Boolean)fromJSON(Type.Bool,obj.get("arg1")); + return tv; + } + case "StencilOp": { + FragmentOperation.StencilOp_ tv = new FragmentOperation().new StencilOp_(); + tv._0 = (StencilTests)fromJSON(Type.StencilTests,obj.get("arg0")); + tv._1 = (StencilOps)fromJSON(Type.StencilOps,obj.get("arg1")); + tv._2 = (StencilOps)fromJSON(Type.StencilOps,obj.get("arg2")); + return tv; + } + case "ColorOp": { + FragmentOperation.ColorOp_ tv = new FragmentOperation().new ColorOp_(); + tv._0 = (Blending)fromJSON(Type.Blending,obj.get("arg0")); + tv._1 = (Value)fromJSON(Type.Value,obj.get("arg1")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case AccumulationContext: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "AccumulationContext": { + AccumulationContext.AccumulationContext_ tv = new AccumulationContext().new AccumulationContext_(); + tv.accViewportName = (Maybe)fromJSON(Type.Maybe_String,obj.get("accViewportName")); + tv.accOperations = (ArrayList)fromJSON(Type.List_FragmentOperation,obj.get("accOperations")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case TextureDataType: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + TextureDataType.Tag tagType; + switch (tag) { + case "FloatT": { + TextureDataType.FloatT_ tv = new TextureDataType().new FloatT_(); + tv._0 = (ColorArity)fromJSON(Type.ColorArity,obj.get("arg0")); + return tv; + } + case "IntT": { + TextureDataType.IntT_ tv = new TextureDataType().new IntT_(); + tv._0 = (ColorArity)fromJSON(Type.ColorArity,obj.get("arg0")); + return tv; + } + case "WordT": { + TextureDataType.WordT_ tv = new TextureDataType().new WordT_(); + tv._0 = (ColorArity)fromJSON(Type.ColorArity,obj.get("arg0")); + return tv; + } + case "ShadowT": tagType = TextureDataType.Tag.ShadowT; break; + default: throw new Exception("unknown constructor: " + tag); + } + TextureDataType o = new TextureDataType(); + o.tag = tagType; + return o; + } + case TextureType: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Texture1D": { + TextureType.Texture1D_ tv = new TextureType().new Texture1D_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + case "Texture2D": { + TextureType.Texture2D_ tv = new TextureType().new Texture2D_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + case "Texture3D": { + TextureType.Texture3D_ tv = new TextureType().new Texture3D_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + return tv; + } + case "TextureCube": { + TextureType.TextureCube_ tv = new TextureType().new TextureCube_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + return tv; + } + case "TextureRect": { + TextureType.TextureRect_ tv = new TextureType().new TextureRect_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + return tv; + } + case "Texture2DMS": { + TextureType.Texture2DMS_ tv = new TextureType().new Texture2DMS_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + tv._2 = (Integer)fromJSON(Type.Int,obj.get("arg2")); + tv._3 = (Boolean)fromJSON(Type.Bool,obj.get("arg3")); + return tv; + } + case "TextureBuffer": { + TextureType.TextureBuffer_ tv = new TextureType().new TextureBuffer_(); + tv._0 = (TextureDataType)fromJSON(Type.TextureDataType,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case MipMap: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + MipMap.Tag tagType; + switch (tag) { + case "Mip": { + MipMap.Mip_ tv = new MipMap().new Mip_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + case "NoMip": tagType = MipMap.Tag.NoMip; break; + case "AutoMip": { + MipMap.AutoMip_ tv = new MipMap().new AutoMip_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + MipMap o = new MipMap(); + o.tag = tagType; + return o; + } + case Filter: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + Filter.Tag tagType; + switch (tag) { + case "Nearest": tagType = Filter.Tag.Nearest; break; + case "Linear": tagType = Filter.Tag.Linear; break; + case "NearestMipmapNearest": tagType = Filter.Tag.NearestMipmapNearest; break; + case "NearestMipmapLinear": tagType = Filter.Tag.NearestMipmapLinear; break; + case "LinearMipmapNearest": tagType = Filter.Tag.LinearMipmapNearest; break; + case "LinearMipmapLinear": tagType = Filter.Tag.LinearMipmapLinear; break; + default: throw new Exception("unknown constructor: " + tag); + } + Filter o = new Filter(); + o.tag = tagType; + return o; + } + case EdgeMode: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + EdgeMode.Tag tagType; + switch (tag) { + case "Repeat": tagType = EdgeMode.Tag.Repeat; break; + case "MirroredRepeat": tagType = EdgeMode.Tag.MirroredRepeat; break; + case "ClampToEdge": tagType = EdgeMode.Tag.ClampToEdge; break; + case "ClampToBorder": tagType = EdgeMode.Tag.ClampToBorder; break; + default: throw new Exception("unknown constructor: " + tag); + } + EdgeMode o = new EdgeMode(); + o.tag = tagType; + return o; + } + case ImageSemantic: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + ImageSemantic.Tag tagType; + switch (tag) { + case "Depth": tagType = ImageSemantic.Tag.Depth; break; + case "Stencil": tagType = ImageSemantic.Tag.Stencil; break; + case "Color": tagType = ImageSemantic.Tag.Color; break; + default: throw new Exception("unknown constructor: " + tag); + } + ImageSemantic o = new ImageSemantic(); + o.tag = tagType; + return o; + } + case ImageRef: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "TextureImage": { + ImageRef.TextureImage_ tv = new ImageRef().new TextureImage_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + tv._2 = (Maybe)fromJSON(Type.Maybe_Int,obj.get("arg2")); + return tv; + } + case "Framebuffer": { + ImageRef.Framebuffer_ tv = new ImageRef().new Framebuffer_(); + tv._0 = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case ClearImage: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "ClearImage": { + ClearImage.ClearImage_ tv = new ClearImage().new ClearImage_(); + tv.imageSemantic = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("imageSemantic")); + tv.clearValue = (Value)fromJSON(Type.Value,obj.get("clearValue")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Command: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "SetRasterContext": { + Command.SetRasterContext_ tv = new Command().new SetRasterContext_(); + tv._0 = (RasterContext)fromJSON(Type.RasterContext,obj.get("arg0")); + return tv; + } + case "SetAccumulationContext": { + Command.SetAccumulationContext_ tv = new Command().new SetAccumulationContext_(); + tv._0 = (AccumulationContext)fromJSON(Type.AccumulationContext,obj.get("arg0")); + return tv; + } + case "SetRenderTarget": { + Command.SetRenderTarget_ tv = new Command().new SetRenderTarget_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + return tv; + } + case "SetProgram": { + Command.SetProgram_ tv = new Command().new SetProgram_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + return tv; + } + case "SetSamplerUniform": { + Command.SetSamplerUniform_ tv = new Command().new SetSamplerUniform_(); + tv._0 = (String)fromJSON(Type.String,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + case "SetTexture": { + Command.SetTexture_ tv = new Command().new SetTexture_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + case "SetSampler": { + Command.SetSampler_ tv = new Command().new SetSampler_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + tv._1 = (Maybe)fromJSON(Type.Maybe_Int,obj.get("arg1")); + return tv; + } + case "RenderSlot": { + Command.RenderSlot_ tv = new Command().new RenderSlot_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + return tv; + } + case "RenderStream": { + Command.RenderStream_ tv = new Command().new RenderStream_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + return tv; + } + case "ClearRenderTarget": { + Command.ClearRenderTarget_ tv = new Command().new ClearRenderTarget_(); + tv._0 = (ArrayList)fromJSON(Type.Array_ClearImage,obj.get("arg0")); + return tv; + } + case "GenerateMipMap": { + Command.GenerateMipMap_ tv = new Command().new GenerateMipMap_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + return tv; + } + case "SaveImage": { + Command.SaveImage_ tv = new Command().new SaveImage_(); + tv._0 = (Integer)fromJSON(Type.Int,obj.get("arg0")); + tv._1 = (ImageRef)fromJSON(Type.ImageRef,obj.get("arg1")); + return tv; + } + case "LoadImage": { + Command.LoadImage_ tv = new Command().new LoadImage_(); + tv._0 = (ImageRef)fromJSON(Type.ImageRef,obj.get("arg0")); + tv._1 = (Integer)fromJSON(Type.Int,obj.get("arg1")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case SamplerDescriptor: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "SamplerDescriptor": { + SamplerDescriptor.SamplerDescriptor_ tv = new SamplerDescriptor().new SamplerDescriptor_(); + tv.samplerWrapS = (EdgeMode)fromJSON(Type.EdgeMode,obj.get("samplerWrapS")); + tv.samplerWrapT = (Maybe)fromJSON(Type.Maybe_EdgeMode,obj.get("samplerWrapT")); + tv.samplerWrapR = (Maybe)fromJSON(Type.Maybe_EdgeMode,obj.get("samplerWrapR")); + tv.samplerMinFilter = (Filter)fromJSON(Type.Filter,obj.get("samplerMinFilter")); + tv.samplerMagFilter = (Filter)fromJSON(Type.Filter,obj.get("samplerMagFilter")); + tv.samplerBorderColor = (Value)fromJSON(Type.Value,obj.get("samplerBorderColor")); + tv.samplerMinLod = (Maybe)fromJSON(Type.Maybe_Float,obj.get("samplerMinLod")); + tv.samplerMaxLod = (Maybe)fromJSON(Type.Maybe_Float,obj.get("samplerMaxLod")); + tv.samplerLodBias = (Float)fromJSON(Type.Float,obj.get("samplerLodBias")); + tv.samplerCompareFunc = (Maybe)fromJSON(Type.Maybe_ComparisonFunction,obj.get("samplerCompareFunc")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case TextureDescriptor: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "TextureDescriptor": { + TextureDescriptor.TextureDescriptor_ tv = new TextureDescriptor().new TextureDescriptor_(); + tv.textureType = (TextureType)fromJSON(Type.TextureType,obj.get("textureType")); + tv.textureSize = (Value)fromJSON(Type.Value,obj.get("textureSize")); + tv.textureSemantic = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("textureSemantic")); + tv.textureSampler = (SamplerDescriptor)fromJSON(Type.SamplerDescriptor,obj.get("textureSampler")); + tv.textureBaseLevel = (Integer)fromJSON(Type.Int,obj.get("textureBaseLevel")); + tv.textureMaxLevel = (Integer)fromJSON(Type.Int,obj.get("textureMaxLevel")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Parameter: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Parameter": { + Parameter.Parameter_ tv = new Parameter().new Parameter_(); + tv.name = (String)fromJSON(Type.String,obj.get("name")); + tv.ty = (InputType)fromJSON(Type.InputType,obj.get("ty")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Program: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Program": { + Program.Program_ tv = new Program().new Program_(); + tv.programUniforms = (HashMap)fromJSON(Type.Map_String_InputType,obj.get("programUniforms")); + tv.programStreams = (HashMap)fromJSON(Type.Map_String_Parameter,obj.get("programStreams")); + tv.programInTextures = (HashMap)fromJSON(Type.Map_String_InputType,obj.get("programInTextures")); + tv.programOutput = (ArrayList)fromJSON(Type.Array_Parameter,obj.get("programOutput")); + tv.vertexShader = (String)fromJSON(Type.String,obj.get("vertexShader")); + tv.geometryShader = (Maybe)fromJSON(Type.Maybe_String,obj.get("geometryShader")); + tv.fragmentShader = (String)fromJSON(Type.String,obj.get("fragmentShader")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Slot: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Slot": { + Slot.Slot_ tv = new Slot().new Slot_(); + tv.slotName = (String)fromJSON(Type.String,obj.get("slotName")); + tv.slotStreams = (HashMap)fromJSON(Type.Map_String_InputType,obj.get("slotStreams")); + tv.slotUniforms = (HashMap)fromJSON(Type.Map_String_InputType,obj.get("slotUniforms")); + tv.slotPrimitive = (FetchPrimitive)fromJSON(Type.FetchPrimitive,obj.get("slotPrimitive")); + tv.slotPrograms = (ArrayList)fromJSON(Type.Array_Int,obj.get("slotPrograms")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case StreamData: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "StreamData": { + StreamData.StreamData_ tv = new StreamData().new StreamData_(); + tv.streamData = (HashMap)fromJSON(Type.Map_String_ArrayValue,obj.get("streamData")); + tv.streamType = (HashMap)fromJSON(Type.Map_String_InputType,obj.get("streamType")); + tv.streamPrimitive = (FetchPrimitive)fromJSON(Type.FetchPrimitive,obj.get("streamPrimitive")); + tv.streamPrograms = (ArrayList)fromJSON(Type.Array_Int,obj.get("streamPrograms")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case TargetItem: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "TargetItem": { + TargetItem.TargetItem_ tv = new TargetItem().new TargetItem_(); + tv.targetSemantic = (ImageSemantic)fromJSON(Type.ImageSemantic,obj.get("targetSemantic")); + tv.targetRef = (Maybe)fromJSON(Type.Maybe_ImageRef,obj.get("targetRef")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case RenderTarget: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "RenderTarget": { + RenderTarget.RenderTarget_ tv = new RenderTarget().new RenderTarget_(); + tv.renderTargets = (ArrayList)fromJSON(Type.Array_TargetItem,obj.get("renderTargets")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Backend: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + Backend.Tag tagType; + switch (tag) { + case "WebGL1": tagType = Backend.Tag.WebGL1; break; + case "OpenGL33": tagType = Backend.Tag.OpenGL33; break; + default: throw new Exception("unknown constructor: " + tag); + } + Backend o = new Backend(); + o.tag = tagType; + return o; + } + case Pipeline: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Pipeline": { + Pipeline.Pipeline_ tv = new Pipeline().new Pipeline_(); + tv.info = (String)fromJSON(Type.String,obj.get("info")); + tv.backend = (Backend)fromJSON(Type.Backend,obj.get("backend")); + tv.textures = (ArrayList)fromJSON(Type.Array_TextureDescriptor,obj.get("textures")); + tv.samplers = (ArrayList)fromJSON(Type.Array_SamplerDescriptor,obj.get("samplers")); + tv.targets = (ArrayList)fromJSON(Type.Array_RenderTarget,obj.get("targets")); + tv.programs = (ArrayList)fromJSON(Type.Array_Program,obj.get("programs")); + tv.slots = (ArrayList)fromJSON(Type.Array_Slot,obj.get("slots")); + tv.streams = (ArrayList)fromJSON(Type.Array_StreamData,obj.get("streams")); + tv.commands = (ArrayList)fromJSON(Type.Array_Command,obj.get("commands")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + } + throw new Exception("unknown type"); + } +} \ No newline at end of file diff --git a/ddl/out/java/LambdaCube/IR/LogicOperation.java b/ddl/out/java/LambdaCube/IR/LogicOperation.java new file mode 100644 index 0000000..351bfe5 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/LogicOperation.java @@ -0,0 +1,33 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class LogicOperation { + public enum Tag { + Clear, + And, + AndReverse, + Copy, + AndInverted, + Noop, + Xor, + Or, + Nor, + Equiv, + Invert, + OrReverse, + CopyInverted, + OrInverted, + Nand, + Set + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/MipMap.java b/ddl/out/java/LambdaCube/IR/MipMap.java new file mode 100644 index 0000000..69c7fb4 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/MipMap.java @@ -0,0 +1,30 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class MipMap { + public enum Tag { + Mip, + NoMip, + AutoMip + } + public Tag tag; + + public class Mip_ extends MipMap { + public Integer _0; + public Integer _1; + public Mip_() { tag = MipMap.Tag.Mip; } + } + public class AutoMip_ extends MipMap { + public Integer _0; + public Integer _1; + public AutoMip_() { tag = MipMap.Tag.AutoMip; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/OutputPrimitive.java b/ddl/out/java/LambdaCube/IR/OutputPrimitive.java new file mode 100644 index 0000000..cda4e7a --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/OutputPrimitive.java @@ -0,0 +1,20 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class OutputPrimitive { + public enum Tag { + TrianglesOutput, + LinesOutput, + PointsOutput + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/Parameter.java b/ddl/out/java/LambdaCube/IR/Parameter.java new file mode 100644 index 0000000..11f6778 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Parameter.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Parameter { + public enum Tag { + Parameter + } + public Tag tag; + + public class Parameter_ extends Parameter { + public String name; + public InputType ty; + public Parameter_() { tag = Parameter.Tag.Parameter; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/Pipeline.java b/ddl/out/java/LambdaCube/IR/Pipeline.java new file mode 100644 index 0000000..5a98897 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Pipeline.java @@ -0,0 +1,30 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Pipeline { + public enum Tag { + Pipeline + } + public Tag tag; + + public class Pipeline_ extends Pipeline { + public String info; + public Backend backend; + public ArrayList textures; + public ArrayList samplers; + public ArrayList targets; + public ArrayList programs; + public ArrayList slots; + public ArrayList streams; + public ArrayList commands; + public Pipeline_() { tag = Pipeline.Tag.Pipeline; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/PointSize.java b/ddl/out/java/LambdaCube/IR/PointSize.java new file mode 100644 index 0000000..195cd89 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/PointSize.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class PointSize { + public enum Tag { + PointSize, + ProgramPointSize + } + public Tag tag; + + public class PointSize_ extends PointSize { + public Float _0; + public PointSize_() { tag = PointSize.Tag.PointSize; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java b/ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java new file mode 100644 index 0000000..6b705bb --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/PointSpriteCoordOrigin.java @@ -0,0 +1,19 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class PointSpriteCoordOrigin { + public enum Tag { + LowerLeft, + UpperLeft + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/PolygonMode.java b/ddl/out/java/LambdaCube/IR/PolygonMode.java new file mode 100644 index 0000000..a1beedc --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/PolygonMode.java @@ -0,0 +1,28 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class PolygonMode { + public enum Tag { + PolygonPoint, + PolygonLine, + PolygonFill + } + public Tag tag; + + public class PolygonPoint_ extends PolygonMode { + public PointSize _0; + public PolygonPoint_() { tag = PolygonMode.Tag.PolygonPoint; } + } + public class PolygonLine_ extends PolygonMode { + public Float _0; + public PolygonLine_() { tag = PolygonMode.Tag.PolygonLine; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/PolygonOffset.java b/ddl/out/java/LambdaCube/IR/PolygonOffset.java new file mode 100644 index 0000000..dea6684 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/PolygonOffset.java @@ -0,0 +1,24 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class PolygonOffset { + public enum Tag { + NoOffset, + Offset + } + public Tag tag; + + public class Offset_ extends PolygonOffset { + public Float _0; + public Float _1; + public Offset_() { tag = PolygonOffset.Tag.Offset; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/Program.java b/ddl/out/java/LambdaCube/IR/Program.java new file mode 100644 index 0000000..4f0e999 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Program.java @@ -0,0 +1,28 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Program { + public enum Tag { + Program + } + public Tag tag; + + public class Program_ extends Program { + public HashMap programUniforms; + public HashMap programStreams; + public HashMap programInTextures; + public ArrayList programOutput; + public String vertexShader; + public Maybe geometryShader; + public String fragmentShader; + public Program_() { tag = Program.Tag.Program; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/ProvokingVertex.java b/ddl/out/java/LambdaCube/IR/ProvokingVertex.java new file mode 100644 index 0000000..30ee0fc --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/ProvokingVertex.java @@ -0,0 +1,19 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class ProvokingVertex { + public enum Tag { + FirstVertex, + LastVertex + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/RasterContext.java b/ddl/out/java/LambdaCube/IR/RasterContext.java new file mode 100644 index 0000000..c246a8a --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/RasterContext.java @@ -0,0 +1,38 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class RasterContext { + public enum Tag { + PointCtx, + LineCtx, + TriangleCtx + } + public Tag tag; + + public class PointCtx_ extends RasterContext { + public PointSize _0; + public Float _1; + public PointSpriteCoordOrigin _2; + public PointCtx_() { tag = RasterContext.Tag.PointCtx; } + } + public class LineCtx_ extends RasterContext { + public Float _0; + public ProvokingVertex _1; + public LineCtx_() { tag = RasterContext.Tag.LineCtx; } + } + public class TriangleCtx_ extends RasterContext { + public CullMode _0; + public PolygonMode _1; + public PolygonOffset _2; + public ProvokingVertex _3; + public TriangleCtx_() { tag = RasterContext.Tag.TriangleCtx; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/RenderTarget.java b/ddl/out/java/LambdaCube/IR/RenderTarget.java new file mode 100644 index 0000000..816dbc6 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/RenderTarget.java @@ -0,0 +1,22 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class RenderTarget { + public enum Tag { + RenderTarget + } + public Tag tag; + + public class RenderTarget_ extends RenderTarget { + public ArrayList renderTargets; + public RenderTarget_() { tag = RenderTarget.Tag.RenderTarget; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/SamplerDescriptor.java b/ddl/out/java/LambdaCube/IR/SamplerDescriptor.java new file mode 100644 index 0000000..1149bf3 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/SamplerDescriptor.java @@ -0,0 +1,31 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class SamplerDescriptor { + public enum Tag { + SamplerDescriptor + } + public Tag tag; + + public class SamplerDescriptor_ extends SamplerDescriptor { + public EdgeMode samplerWrapS; + public Maybe samplerWrapT; + public Maybe samplerWrapR; + public Filter samplerMinFilter; + public Filter samplerMagFilter; + public Value samplerBorderColor; + public Maybe samplerMinLod; + public Maybe samplerMaxLod; + public Float samplerLodBias; + public Maybe samplerCompareFunc; + public SamplerDescriptor_() { tag = SamplerDescriptor.Tag.SamplerDescriptor; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/Slot.java b/ddl/out/java/LambdaCube/IR/Slot.java new file mode 100644 index 0000000..bd6fac3 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Slot.java @@ -0,0 +1,26 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Slot { + public enum Tag { + Slot + } + public Tag tag; + + public class Slot_ extends Slot { + public String slotName; + public HashMap slotStreams; + public HashMap slotUniforms; + public FetchPrimitive slotPrimitive; + public ArrayList slotPrograms; + public Slot_() { tag = Slot.Tag.Slot; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/StencilOperation.java b/ddl/out/java/LambdaCube/IR/StencilOperation.java new file mode 100644 index 0000000..ef3a62f --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/StencilOperation.java @@ -0,0 +1,25 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class StencilOperation { + public enum Tag { + OpZero, + OpKeep, + OpReplace, + OpIncr, + OpIncrWrap, + OpDecr, + OpDecrWrap, + OpInvert + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/IR/StencilOps.java b/ddl/out/java/LambdaCube/IR/StencilOps.java new file mode 100644 index 0000000..54f6d95 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/StencilOps.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class StencilOps { + public enum Tag { + StencilOps + } + public Tag tag; + + public class StencilOps_ extends StencilOps { + public StencilOperation frontStencilOp; + public StencilOperation backStencilOp; + public StencilOps_() { tag = StencilOps.Tag.StencilOps; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/StencilTest.java b/ddl/out/java/LambdaCube/IR/StencilTest.java new file mode 100644 index 0000000..ef16647 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/StencilTest.java @@ -0,0 +1,24 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class StencilTest { + public enum Tag { + StencilTest + } + public Tag tag; + + public class StencilTest_ extends StencilTest { + public ComparisonFunction stencilComparision; + public Integer stencilReference; + public Integer stencilMask; + public StencilTest_() { tag = StencilTest.Tag.StencilTest; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/StencilTests.java b/ddl/out/java/LambdaCube/IR/StencilTests.java new file mode 100644 index 0000000..d350f5f --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/StencilTests.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class StencilTests { + public enum Tag { + StencilTests + } + public Tag tag; + + public class StencilTests_ extends StencilTests { + public StencilTest _0; + public StencilTest _1; + public StencilTests_() { tag = StencilTests.Tag.StencilTests; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/StreamData.java b/ddl/out/java/LambdaCube/IR/StreamData.java new file mode 100644 index 0000000..81c9d0b --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/StreamData.java @@ -0,0 +1,25 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class StreamData { + public enum Tag { + StreamData + } + public Tag tag; + + public class StreamData_ extends StreamData { + public HashMap streamData; + public HashMap streamType; + public FetchPrimitive streamPrimitive; + public ArrayList streamPrograms; + public StreamData_() { tag = StreamData.Tag.StreamData; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/TargetItem.java b/ddl/out/java/LambdaCube/IR/TargetItem.java new file mode 100644 index 0000000..f6315fc --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/TargetItem.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class TargetItem { + public enum Tag { + TargetItem + } + public Tag tag; + + public class TargetItem_ extends TargetItem { + public ImageSemantic targetSemantic; + public Maybe targetRef; + public TargetItem_() { tag = TargetItem.Tag.TargetItem; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/TextureDataType.java b/ddl/out/java/LambdaCube/IR/TextureDataType.java new file mode 100644 index 0000000..4725a3f --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/TextureDataType.java @@ -0,0 +1,33 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class TextureDataType { + public enum Tag { + FloatT, + IntT, + WordT, + ShadowT + } + public Tag tag; + + public class FloatT_ extends TextureDataType { + public ColorArity _0; + public FloatT_() { tag = TextureDataType.Tag.FloatT; } + } + public class IntT_ extends TextureDataType { + public ColorArity _0; + public IntT_() { tag = TextureDataType.Tag.IntT; } + } + public class WordT_ extends TextureDataType { + public ColorArity _0; + public WordT_() { tag = TextureDataType.Tag.WordT; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/TextureDescriptor.java b/ddl/out/java/LambdaCube/IR/TextureDescriptor.java new file mode 100644 index 0000000..d4d3cdd --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/TextureDescriptor.java @@ -0,0 +1,27 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class TextureDescriptor { + public enum Tag { + TextureDescriptor + } + public Tag tag; + + public class TextureDescriptor_ extends TextureDescriptor { + public TextureType textureType; + public Value textureSize; + public ImageSemantic textureSemantic; + public SamplerDescriptor textureSampler; + public Integer textureBaseLevel; + public Integer textureMaxLevel; + public TextureDescriptor_() { tag = TextureDescriptor.Tag.TextureDescriptor; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/TextureType.java b/ddl/out/java/LambdaCube/IR/TextureType.java new file mode 100644 index 0000000..2425c1f --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/TextureType.java @@ -0,0 +1,57 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class TextureType { + public enum Tag { + Texture1D, + Texture2D, + Texture3D, + TextureCube, + TextureRect, + Texture2DMS, + TextureBuffer + } + public Tag tag; + + public class Texture1D_ extends TextureType { + public TextureDataType _0; + public Integer _1; + public Texture1D_() { tag = TextureType.Tag.Texture1D; } + } + public class Texture2D_ extends TextureType { + public TextureDataType _0; + public Integer _1; + public Texture2D_() { tag = TextureType.Tag.Texture2D; } + } + public class Texture3D_ extends TextureType { + public TextureDataType _0; + public Texture3D_() { tag = TextureType.Tag.Texture3D; } + } + public class TextureCube_ extends TextureType { + public TextureDataType _0; + public TextureCube_() { tag = TextureType.Tag.TextureCube; } + } + public class TextureRect_ extends TextureType { + public TextureDataType _0; + public TextureRect_() { tag = TextureType.Tag.TextureRect; } + } + public class Texture2DMS_ extends TextureType { + public TextureDataType _0; + public Integer _1; + public Integer _2; + public Boolean _3; + public Texture2DMS_() { tag = TextureType.Tag.Texture2DMS; } + } + public class TextureBuffer_ extends TextureType { + public TextureDataType _0; + public TextureBuffer_() { tag = TextureType.Tag.TextureBuffer; } + } +} + diff --git a/ddl/out/java/LambdaCube/IR/Value.java b/ddl/out/java/LambdaCube/IR/Value.java new file mode 100644 index 0000000..75de175 --- /dev/null +++ b/ddl/out/java/LambdaCube/IR/Value.java @@ -0,0 +1,142 @@ +// generated file, do not modify! +// 2016-03-21T11:41:51.714241000000Z + +package LambdaCube.IR; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Value { + public enum 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 + } + public Tag tag; + + public class VBool_ extends Value { + public Boolean _0; + public VBool_() { tag = Value.Tag.VBool; } + } + public class VV2B_ extends Value { + public V2 _0; + public VV2B_() { tag = Value.Tag.VV2B; } + } + public class VV3B_ extends Value { + public V3 _0; + public VV3B_() { tag = Value.Tag.VV3B; } + } + public class VV4B_ extends Value { + public V4 _0; + public VV4B_() { tag = Value.Tag.VV4B; } + } + public class VWord_ extends Value { + public Integer _0; + public VWord_() { tag = Value.Tag.VWord; } + } + public class VV2U_ extends Value { + public V2 _0; + public VV2U_() { tag = Value.Tag.VV2U; } + } + public class VV3U_ extends Value { + public V3 _0; + public VV3U_() { tag = Value.Tag.VV3U; } + } + public class VV4U_ extends Value { + public V4 _0; + public VV4U_() { tag = Value.Tag.VV4U; } + } + public class VInt_ extends Value { + public Integer _0; + public VInt_() { tag = Value.Tag.VInt; } + } + public class VV2I_ extends Value { + public V2 _0; + public VV2I_() { tag = Value.Tag.VV2I; } + } + public class VV3I_ extends Value { + public V3 _0; + public VV3I_() { tag = Value.Tag.VV3I; } + } + public class VV4I_ extends Value { + public V4 _0; + public VV4I_() { tag = Value.Tag.VV4I; } + } + public class VFloat_ extends Value { + public Float _0; + public VFloat_() { tag = Value.Tag.VFloat; } + } + public class VV2F_ extends Value { + public V2 _0; + public VV2F_() { tag = Value.Tag.VV2F; } + } + public class VV3F_ extends Value { + public V3 _0; + public VV3F_() { tag = Value.Tag.VV3F; } + } + public class VV4F_ extends Value { + public V4 _0; + public VV4F_() { tag = Value.Tag.VV4F; } + } + public class VM22F_ extends Value { + public V2> _0; + public VM22F_() { tag = Value.Tag.VM22F; } + } + public class VM23F_ extends Value { + public V3> _0; + public VM23F_() { tag = Value.Tag.VM23F; } + } + public class VM24F_ extends Value { + public V4> _0; + public VM24F_() { tag = Value.Tag.VM24F; } + } + public class VM32F_ extends Value { + public V2> _0; + public VM32F_() { tag = Value.Tag.VM32F; } + } + public class VM33F_ extends Value { + public V3> _0; + public VM33F_() { tag = Value.Tag.VM33F; } + } + public class VM34F_ extends Value { + public V4> _0; + public VM34F_() { tag = Value.Tag.VM34F; } + } + public class VM42F_ extends Value { + public V2> _0; + public VM42F_() { tag = Value.Tag.VM42F; } + } + public class VM43F_ extends Value { + public V3> _0; + public VM43F_() { tag = Value.Tag.VM43F; } + } + public class VM44F_ extends Value { + public V4> _0; + public VM44F_() { tag = Value.Tag.VM44F; } + } +} + diff --git a/ddl/out/java/LambdaCube/Mesh/JSON.java b/ddl/out/java/LambdaCube/Mesh/JSON.java new file mode 100644 index 0000000..db0641e --- /dev/null +++ b/ddl/out/java/LambdaCube/Mesh/JSON.java @@ -0,0 +1,206 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.391032000000Z + +package LambdaCube.Mesh; + +import java.util.ArrayList; +import java.util.HashMap; +import org.json.*; +import RT.*; + + +public class JSON { + // JSON deserializer + public enum Type { + Int32, + Word32, + Float, + String, + V2_Float, + V2_V2_Float, + V3_Float, + V3_V3_Float, + V4_Float, + V4_V4_Float, + Array_Int32, + Array_Word32, + Array_Float, + Array_V2_Float, + Array_V2_V2_Float, + Array_V3_Float, + Array_V3_V3_Float, + Array_V4_Float, + Array_V4_V4_Float, + Map_String_MeshAttribute, + Mesh, + MeshAttribute, + MeshPrimitive + } + + public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception { + switch (type) { + case Int32: return (Integer)rawObj; + case Word32: return (Integer)rawObj; + case Float: return (Float)rawObj; + case String: return (String)rawObj; + case V2_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V2 + ( (Float)fromJSON(Type.Float,obj.get("x")) + , (Float)fromJSON(Type.Float,obj.get("y")) + ); + } + case V2_V2_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V2> + ( (V2)fromJSON(Type.V2_Float,obj.get("x")) + , (V2)fromJSON(Type.V2_Float,obj.get("y")) + ); + } + case V3_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V3 + ( (Float)fromJSON(Type.Float,obj.get("x")) + , (Float)fromJSON(Type.Float,obj.get("y")) + , (Float)fromJSON(Type.Float,obj.get("z")) + ); + } + case V3_V3_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V3> + ( (V3)fromJSON(Type.V3_Float,obj.get("x")) + , (V3)fromJSON(Type.V3_Float,obj.get("y")) + , (V3)fromJSON(Type.V3_Float,obj.get("z")) + ); + } + case V4_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V4 + ( (Float)fromJSON(Type.Float,obj.get("x")) + , (Float)fromJSON(Type.Float,obj.get("y")) + , (Float)fromJSON(Type.Float,obj.get("z")) + , (Float)fromJSON(Type.Float,obj.get("w")) + ); + } + case V4_V4_Float: { + JSONObject obj = (JSONObject)rawObj; + return new V4> + ( (V4)fromJSON(Type.V4_Float,obj.get("x")) + , (V4)fromJSON(Type.V4_Float,obj.get("y")) + , (V4)fromJSON(Type.V4_Float,obj.get("z")) + , (V4)fromJSON(Type.V4_Float,obj.get("w")) + ); + } +// case Array_Int32: return ((JArray)obj).Select(x => fromJSON (Type.Int32, x)).ToList(); +// case Array_Word32: return ((JArray)obj).Select(x => fromJSON (Type.Word32, x)).ToList(); +// case Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList(); +// case Array_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_Float, x)).ToList(); +// case Array_V2_V2_Float: return ((JArray)obj).Select(x => fromJSON (Type.V2_V2_Float, x)).ToList(); +// case Array_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_Float, x)).ToList(); +// case Array_V3_V3_Float: return ((JArray)obj).Select(x => fromJSON (Type.V3_V3_Float, x)).ToList(); +// case Array_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_Float, x)).ToList(); +// case Array_V4_V4_Float: return ((JArray)obj).Select(x => fromJSON (Type.V4_V4_Float, x)).ToList(); +/* + case Map_String_MeshAttribute: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (MeshAttribute)fromJSON(Type.MeshAttribute,i.Value)); + } + return map; + } +*/ + + case MeshAttribute: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "A_Float": { + MeshAttribute.A_Float_ tv = new MeshAttribute().new A_Float_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Float,obj.get("arg0")); + return tv; + } + case "A_V2F": { + MeshAttribute.A_V2F_ tv = new MeshAttribute().new A_V2F_(); + tv._0 = (ArrayList>)fromJSON(Type.Array_V2_Float,obj.get("arg0")); + return tv; + } + case "A_V3F": { + MeshAttribute.A_V3F_ tv = new MeshAttribute().new A_V3F_(); + tv._0 = (ArrayList>)fromJSON(Type.Array_V3_Float,obj.get("arg0")); + return tv; + } + case "A_V4F": { + MeshAttribute.A_V4F_ tv = new MeshAttribute().new A_V4F_(); + tv._0 = (ArrayList>)fromJSON(Type.Array_V4_Float,obj.get("arg0")); + return tv; + } + case "A_M22F": { + MeshAttribute.A_M22F_ tv = new MeshAttribute().new A_M22F_(); + tv._0 = (ArrayList>>)fromJSON(Type.Array_V2_V2_Float,obj.get("arg0")); + return tv; + } + case "A_M33F": { + MeshAttribute.A_M33F_ tv = new MeshAttribute().new A_M33F_(); + tv._0 = (ArrayList>>)fromJSON(Type.Array_V3_V3_Float,obj.get("arg0")); + return tv; + } + case "A_M44F": { + MeshAttribute.A_M44F_ tv = new MeshAttribute().new A_M44F_(); + tv._0 = (ArrayList>>)fromJSON(Type.Array_V4_V4_Float,obj.get("arg0")); + return tv; + } + case "A_Int": { + MeshAttribute.A_Int_ tv = new MeshAttribute().new A_Int_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Int32,obj.get("arg0")); + return tv; + } + case "A_Word": { + MeshAttribute.A_Word_ tv = new MeshAttribute().new A_Word_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Word32,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case MeshPrimitive: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + MeshPrimitive.Tag tagType; + switch (tag) { + case "P_Points": tagType = MeshPrimitive.Tag.P_Points; break; + case "P_TriangleStrip": tagType = MeshPrimitive.Tag.P_TriangleStrip; break; + case "P_Triangles": tagType = MeshPrimitive.Tag.P_Triangles; break; + case "P_TriangleStripI": { + MeshPrimitive.P_TriangleStripI_ tv = new MeshPrimitive().new P_TriangleStripI_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Int32,obj.get("arg0")); + return tv; + } + case "P_TrianglesI": { + MeshPrimitive.P_TrianglesI_ tv = new MeshPrimitive().new P_TrianglesI_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Int32,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + MeshPrimitive o = new MeshPrimitive(); + o.tag = tagType; + return o; + } + case Mesh: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Mesh": { + Mesh.Mesh_ tv = new Mesh().new Mesh_(); + tv.mAttributes = (HashMap)fromJSON(Type.Map_String_MeshAttribute,obj.get("mAttributes")); + tv.mPrimitive = (MeshPrimitive)fromJSON(Type.MeshPrimitive,obj.get("mPrimitive")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + } + throw new Exception("unknown type"); + } +} \ No newline at end of file diff --git a/ddl/out/java/LambdaCube/Mesh/Mesh.java b/ddl/out/java/LambdaCube/Mesh/Mesh.java new file mode 100644 index 0000000..b708db9 --- /dev/null +++ b/ddl/out/java/LambdaCube/Mesh/Mesh.java @@ -0,0 +1,23 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.391032000000Z + +package LambdaCube.Mesh; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class Mesh { + public enum Tag { + Mesh + } + public Tag tag; + + public class Mesh_ extends Mesh { + public HashMap mAttributes; + public MeshPrimitive mPrimitive; + public Mesh_() { tag = Mesh.Tag.Mesh; } + } +} + diff --git a/ddl/out/java/LambdaCube/Mesh/MeshAttribute.java b/ddl/out/java/LambdaCube/Mesh/MeshAttribute.java new file mode 100644 index 0000000..585138c --- /dev/null +++ b/ddl/out/java/LambdaCube/Mesh/MeshAttribute.java @@ -0,0 +1,62 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.391032000000Z + +package LambdaCube.Mesh; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class MeshAttribute { + public enum Tag { + A_Float, + A_V2F, + A_V3F, + A_V4F, + A_M22F, + A_M33F, + A_M44F, + A_Int, + A_Word + } + public Tag tag; + + public class A_Float_ extends MeshAttribute { + public ArrayList _0; + public A_Float_() { tag = MeshAttribute.Tag.A_Float; } + } + public class A_V2F_ extends MeshAttribute { + public ArrayList> _0; + public A_V2F_() { tag = MeshAttribute.Tag.A_V2F; } + } + public class A_V3F_ extends MeshAttribute { + public ArrayList> _0; + public A_V3F_() { tag = MeshAttribute.Tag.A_V3F; } + } + public class A_V4F_ extends MeshAttribute { + public ArrayList> _0; + public A_V4F_() { tag = MeshAttribute.Tag.A_V4F; } + } + public class A_M22F_ extends MeshAttribute { + public ArrayList>> _0; + public A_M22F_() { tag = MeshAttribute.Tag.A_M22F; } + } + public class A_M33F_ extends MeshAttribute { + public ArrayList>> _0; + public A_M33F_() { tag = MeshAttribute.Tag.A_M33F; } + } + public class A_M44F_ extends MeshAttribute { + public ArrayList>> _0; + public A_M44F_() { tag = MeshAttribute.Tag.A_M44F; } + } + public class A_Int_ extends MeshAttribute { + public ArrayList _0; + public A_Int_() { tag = MeshAttribute.Tag.A_Int; } + } + public class A_Word_ extends MeshAttribute { + public ArrayList _0; + public A_Word_() { tag = MeshAttribute.Tag.A_Word; } + } +} + diff --git a/ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java b/ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java new file mode 100644 index 0000000..8fd3b52 --- /dev/null +++ b/ddl/out/java/LambdaCube/Mesh/MeshPrimitive.java @@ -0,0 +1,30 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.391032000000Z + +package LambdaCube.Mesh; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + + +public class MeshPrimitive { + public enum Tag { + P_Points, + P_TriangleStrip, + P_Triangles, + P_TriangleStripI, + P_TrianglesI + } + public Tag tag; + + public class P_TriangleStripI_ extends MeshPrimitive { + public ArrayList _0; + public P_TriangleStripI_() { tag = MeshPrimitive.Tag.P_TriangleStripI; } + } + public class P_TrianglesI_ extends MeshPrimitive { + public ArrayList _0; + public P_TrianglesI_() { tag = MeshPrimitive.Tag.P_TrianglesI; } + } +} + diff --git a/ddl/out/java/LambdaCube/PipelineSchema/JSON.java b/ddl/out/java/LambdaCube/PipelineSchema/JSON.java new file mode 100644 index 0000000..4303a7f --- /dev/null +++ b/ddl/out/java/LambdaCube/PipelineSchema/JSON.java @@ -0,0 +1,122 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.343859000000Z + +package LambdaCube.PipelineSchema; + +import java.util.ArrayList; +import java.util.HashMap; +import org.json.*; +import RT.*; + +import LambdaCube.IR.*; + +public class JSON { + // JSON deserializer + public enum Type { + String, + Map_String_InputType, + Map_String_ObjectArraySchema, + Map_String_StreamType, + FetchPrimitive, + InputType, + ObjectArraySchema, + PipelineSchema, + StreamType + } + + public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception { + switch (type) { + case String: return (String)rawObj; +/* + case Map_String_InputType: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (InputType)fromJSON(Type.InputType,i.Value)); + } + return map; + } +*/ +/* + case Map_String_ObjectArraySchema: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (ObjectArraySchema)fromJSON(Type.ObjectArraySchema,i.Value)); + } + return map; + } +*/ +/* + case Map_String_StreamType: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (StreamType)fromJSON(Type.StreamType,i.Value)); + } + return map; + } +*/ + + case StreamType: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + StreamType.Tag tagType; + switch (tag) { + case "Attribute_Word": tagType = StreamType.Tag.Attribute_Word; break; + case "Attribute_V2U": tagType = StreamType.Tag.Attribute_V2U; break; + case "Attribute_V3U": tagType = StreamType.Tag.Attribute_V3U; break; + case "Attribute_V4U": tagType = StreamType.Tag.Attribute_V4U; break; + case "Attribute_Int": tagType = StreamType.Tag.Attribute_Int; break; + case "Attribute_V2I": tagType = StreamType.Tag.Attribute_V2I; break; + case "Attribute_V3I": tagType = StreamType.Tag.Attribute_V3I; break; + case "Attribute_V4I": tagType = StreamType.Tag.Attribute_V4I; break; + case "Attribute_Float": tagType = StreamType.Tag.Attribute_Float; break; + case "Attribute_V2F": tagType = StreamType.Tag.Attribute_V2F; break; + case "Attribute_V3F": tagType = StreamType.Tag.Attribute_V3F; break; + case "Attribute_V4F": tagType = StreamType.Tag.Attribute_V4F; break; + case "Attribute_M22F": tagType = StreamType.Tag.Attribute_M22F; break; + case "Attribute_M23F": tagType = StreamType.Tag.Attribute_M23F; break; + case "Attribute_M24F": tagType = StreamType.Tag.Attribute_M24F; break; + case "Attribute_M32F": tagType = StreamType.Tag.Attribute_M32F; break; + case "Attribute_M33F": tagType = StreamType.Tag.Attribute_M33F; break; + case "Attribute_M34F": tagType = StreamType.Tag.Attribute_M34F; break; + case "Attribute_M42F": tagType = StreamType.Tag.Attribute_M42F; break; + case "Attribute_M43F": tagType = StreamType.Tag.Attribute_M43F; break; + case "Attribute_M44F": tagType = StreamType.Tag.Attribute_M44F; break; + default: throw new Exception("unknown constructor: " + tag); + } + StreamType o = new StreamType(); + o.tag = tagType; + return o; + } + case ObjectArraySchema: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "ObjectArraySchema": { + ObjectArraySchema.ObjectArraySchema_ tv = new ObjectArraySchema().new ObjectArraySchema_(); + tv.primitive = (FetchPrimitive)fromJSON(Type.FetchPrimitive,obj.get("primitive")); + tv.attributes = (HashMap)fromJSON(Type.Map_String_StreamType,obj.get("attributes")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case PipelineSchema: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "PipelineSchema": { + PipelineSchema.PipelineSchema_ tv = new PipelineSchema().new PipelineSchema_(); + tv.objectArrays = (HashMap)fromJSON(Type.Map_String_ObjectArraySchema,obj.get("objectArrays")); + tv.uniforms = (HashMap)fromJSON(Type.Map_String_InputType,obj.get("uniforms")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + } + throw new Exception("unknown type"); + } +} \ No newline at end of file diff --git a/ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java b/ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java new file mode 100644 index 0000000..ffbcf56 --- /dev/null +++ b/ddl/out/java/LambdaCube/PipelineSchema/ObjectArraySchema.java @@ -0,0 +1,24 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.343859000000Z + +package LambdaCube.PipelineSchema; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; + +public class ObjectArraySchema { + public enum Tag { + ObjectArraySchema + } + public Tag tag; + + public class ObjectArraySchema_ extends ObjectArraySchema { + public FetchPrimitive primitive; + public HashMap attributes; + public ObjectArraySchema_() { tag = ObjectArraySchema.Tag.ObjectArraySchema; } + } +} + diff --git a/ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java b/ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java new file mode 100644 index 0000000..a2f22ac --- /dev/null +++ b/ddl/out/java/LambdaCube/PipelineSchema/PipelineSchema.java @@ -0,0 +1,24 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.343859000000Z + +package LambdaCube.PipelineSchema; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; + +public class PipelineSchema { + public enum Tag { + PipelineSchema + } + public Tag tag; + + public class PipelineSchema_ extends PipelineSchema { + public HashMap objectArrays; + public HashMap uniforms; + public PipelineSchema_() { tag = PipelineSchema.Tag.PipelineSchema; } + } +} + diff --git a/ddl/out/java/LambdaCube/PipelineSchema/StreamType.java b/ddl/out/java/LambdaCube/PipelineSchema/StreamType.java new file mode 100644 index 0000000..75af8d5 --- /dev/null +++ b/ddl/out/java/LambdaCube/PipelineSchema/StreamType.java @@ -0,0 +1,39 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.343859000000Z + +package LambdaCube.PipelineSchema; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; + +public class StreamType { + public enum Tag { + Attribute_Word, + Attribute_V2U, + Attribute_V3U, + Attribute_V4U, + Attribute_Int, + Attribute_V2I, + Attribute_V3I, + Attribute_V4I, + Attribute_Float, + Attribute_V2F, + Attribute_V3F, + Attribute_V4F, + Attribute_M22F, + Attribute_M23F, + Attribute_M24F, + Attribute_M32F, + Attribute_M33F, + Attribute_M34F, + Attribute_M42F, + Attribute_M43F, + Attribute_M44F + } + public Tag tag; + +} + diff --git a/ddl/out/java/LambdaCube/TypeInfo/CompileResult.java b/ddl/out/java/LambdaCube/TypeInfo/CompileResult.java new file mode 100644 index 0000000..340d92e --- /dev/null +++ b/ddl/out/java/LambdaCube/TypeInfo/CompileResult.java @@ -0,0 +1,32 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.460562000000Z + +package LambdaCube.TypeInfo; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; + +public class CompileResult { + public enum Tag { + CompileError, + Compiled + } + public Tag tag; + + public class CompileError_ extends CompileResult { + public ArrayList _0; + public String _1; + public ArrayList _2; + public CompileError_() { tag = CompileResult.Tag.CompileError; } + } + public class Compiled_ extends CompileResult { + public String _0; + public Pipeline _1; + public ArrayList _2; + public Compiled_() { tag = CompileResult.Tag.Compiled; } + } +} + diff --git a/ddl/out/java/LambdaCube/TypeInfo/JSON.java b/ddl/out/java/LambdaCube/TypeInfo/JSON.java new file mode 100644 index 0000000..410ce3f --- /dev/null +++ b/ddl/out/java/LambdaCube/TypeInfo/JSON.java @@ -0,0 +1,85 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.460562000000Z + +package LambdaCube.TypeInfo; + +import java.util.ArrayList; +import java.util.HashMap; +import org.json.*; +import RT.*; + +import LambdaCube.IR.*; + +public class JSON { + // JSON deserializer + public enum Type { + Int, + String, + Array_Range, + Array_TypeInfo, + CompileResult, + Pipeline, + Range, + TypeInfo + } + + public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception { + switch (type) { + case Int: return (Integer)rawObj; + case String: return (String)rawObj; +// case Array_Range: return ((JArray)obj).Select(x => fromJSON (Type.Range, x)).ToList(); +// case Array_TypeInfo: return ((JArray)obj).Select(x => fromJSON (Type.TypeInfo, x)).ToList(); + + case Range: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Range": { + Range.Range_ tv = new Range().new Range_(); + tv.startLine = (Integer)fromJSON(Type.Int,obj.get("startLine")); + tv.startColumn = (Integer)fromJSON(Type.Int,obj.get("startColumn")); + tv.endLine = (Integer)fromJSON(Type.Int,obj.get("endLine")); + tv.endColumn = (Integer)fromJSON(Type.Int,obj.get("endColumn")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case TypeInfo: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "TypeInfo": { + TypeInfo.TypeInfo_ tv = new TypeInfo().new TypeInfo_(); + tv.range = (Range)fromJSON(Type.Range,obj.get("range")); + tv.text = (String)fromJSON(Type.String,obj.get("text")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case CompileResult: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "CompileError": { + CompileResult.CompileError_ tv = new CompileResult().new CompileError_(); + tv._0 = (ArrayList)fromJSON(Type.Array_Range,obj.get("arg0")); + tv._1 = (String)fromJSON(Type.String,obj.get("arg1")); + tv._2 = (ArrayList)fromJSON(Type.Array_TypeInfo,obj.get("arg2")); + return tv; + } + case "Compiled": { + CompileResult.Compiled_ tv = new CompileResult().new Compiled_(); + tv._0 = (String)fromJSON(Type.String,obj.get("arg0")); + tv._1 = (Pipeline)fromJSON(Type.Pipeline,obj.get("arg1")); + tv._2 = (ArrayList)fromJSON(Type.Array_TypeInfo,obj.get("arg2")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + } + throw new Exception("unknown type"); + } +} \ No newline at end of file diff --git a/ddl/out/java/LambdaCube/TypeInfo/Range.java b/ddl/out/java/LambdaCube/TypeInfo/Range.java new file mode 100644 index 0000000..8bb89d4 --- /dev/null +++ b/ddl/out/java/LambdaCube/TypeInfo/Range.java @@ -0,0 +1,26 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.460562000000Z + +package LambdaCube.TypeInfo; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; + +public class Range { + public enum Tag { + Range + } + public Tag tag; + + public class Range_ extends Range { + public Integer startLine; + public Integer startColumn; + public Integer endLine; + public Integer endColumn; + public Range_() { tag = Range.Tag.Range; } + } +} + diff --git a/ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java b/ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java new file mode 100644 index 0000000..a134fdb --- /dev/null +++ b/ddl/out/java/LambdaCube/TypeInfo/TypeInfo.java @@ -0,0 +1,24 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.460562000000Z + +package LambdaCube.TypeInfo; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; + +public class TypeInfo { + public enum Tag { + TypeInfo + } + public Tag tag; + + public class TypeInfo_ extends TypeInfo { + public Range range; + public String text; + public TypeInfo_() { tag = TypeInfo.Tag.TypeInfo; } + } +} + diff --git a/ddl/out/java/TestData/ClientInfo.java b/ddl/out/java/TestData/ClientInfo.java new file mode 100644 index 0000000..667c957 --- /dev/null +++ b/ddl/out/java/TestData/ClientInfo.java @@ -0,0 +1,26 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class ClientInfo { + public enum Tag { + ClientInfo + } + public Tag tag; + + public class ClientInfo_ extends ClientInfo { + public String clientName; + public Backend clientBackend; + public ClientInfo_() { tag = ClientInfo.Tag.ClientInfo; } + } +} + diff --git a/ddl/out/java/TestData/Frame.java b/ddl/out/java/TestData/Frame.java new file mode 100644 index 0000000..39db4a4 --- /dev/null +++ b/ddl/out/java/TestData/Frame.java @@ -0,0 +1,27 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class Frame { + public enum Tag { + Frame + } + public Tag tag; + + public class Frame_ extends Frame { + public Integer renderCount; + public HashMap frameUniforms; + public HashMap frameTextures; + public Frame_() { tag = Frame.Tag.Frame; } + } +} + diff --git a/ddl/out/java/TestData/FrameResult.java b/ddl/out/java/TestData/FrameResult.java new file mode 100644 index 0000000..e1e51db --- /dev/null +++ b/ddl/out/java/TestData/FrameResult.java @@ -0,0 +1,27 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class FrameResult { + public enum Tag { + FrameResult + } + public Tag tag; + + public class FrameResult_ extends FrameResult { + public ArrayList frRenderTimes; + public Integer frImageWidth; + public Integer frImageHeight; + public FrameResult_() { tag = FrameResult.Tag.FrameResult; } + } +} + diff --git a/ddl/out/java/TestData/JSON.java b/ddl/out/java/TestData/JSON.java new file mode 100644 index 0000000..4fbe47e --- /dev/null +++ b/ddl/out/java/TestData/JSON.java @@ -0,0 +1,193 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import org.json.*; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class JSON { + // JSON deserializer + public enum Type { + Int, + Float, + String, + Array_Int, + Array_Float, + Array_String, + Array_Frame, + Array_Mesh, + Array_PipelineInfo, + Array_Scene, + Map_String_Int, + Map_String_Array_Int, + Map_String_Value, + Backend, + ClientInfo, + Frame, + FrameResult, + Mesh, + Pipeline, + PipelineInfo, + PipelineSchema, + RenderJob, + RenderJobResult, + Scene, + Value + } + + public static Object fromJSON(Type type, Object rawObj) throws JSONException, Exception { + switch (type) { + case Int: return (Integer)rawObj; + case Float: return (Float)rawObj; + case String: return (String)rawObj; +// case Array_Int: return ((JArray)obj).Select(x => fromJSON (Type.Int, x)).ToList(); +// case Array_Float: return ((JArray)obj).Select(x => fromJSON (Type.Float, x)).ToList(); +// case Array_String: return ((JArray)obj).Select(x => fromJSON (Type.String, x)).ToList(); +// case Array_Frame: return ((JArray)obj).Select(x => fromJSON (Type.Frame, x)).ToList(); +// case Array_Mesh: return ((JArray)obj).Select(x => fromJSON (Type.Mesh, x)).ToList(); +// case Array_PipelineInfo: return ((JArray)obj).Select(x => fromJSON (Type.PipelineInfo, x)).ToList(); +// case Array_Scene: return ((JArray)obj).Select(x => fromJSON (Type.Scene, x)).ToList(); +/* + case Map_String_Int: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (Integer)fromJSON(Type.Int,i.Value)); + } + return map; + } +*/ +/* + case Map_String_Array_Int: { + var map = new HashMap> (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (ArrayList)fromJSON(Type.Array_Int,i.Value)); + } + return map; + } +*/ +/* + case Map_String_Value: { + var map = new HashMap (); + foreach(var i in (JSONObject)rawObj) { + map.Add( (String)fromJSON(Type.String,i.Key) + , (Value)fromJSON(Type.Value,i.Value)); + } + return map; + } +*/ + + case ClientInfo: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "ClientInfo": { + ClientInfo.ClientInfo_ tv = new ClientInfo().new ClientInfo_(); + tv.clientName = (String)fromJSON(Type.String,obj.get("clientName")); + tv.clientBackend = (Backend)fromJSON(Type.Backend,obj.get("clientBackend")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Frame: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Frame": { + Frame.Frame_ tv = new Frame().new Frame_(); + tv.renderCount = (Integer)fromJSON(Type.Int,obj.get("renderCount")); + tv.frameUniforms = (HashMap)fromJSON(Type.Map_String_Value,obj.get("frameUniforms")); + tv.frameTextures = (HashMap)fromJSON(Type.Map_String_Int,obj.get("frameTextures")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case Scene: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "Scene": { + Scene.Scene_ tv = new Scene().new Scene_(); + tv.objectArrays = (HashMap>)fromJSON(Type.Map_String_Array_Int,obj.get("objectArrays")); + tv.renderTargetWidth = (Integer)fromJSON(Type.Int,obj.get("renderTargetWidth")); + tv.renderTargetHeight = (Integer)fromJSON(Type.Int,obj.get("renderTargetHeight")); + tv.frames = (ArrayList)fromJSON(Type.Array_Frame,obj.get("frames")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case PipelineInfo: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "PipelineInfo": { + PipelineInfo.PipelineInfo_ tv = new PipelineInfo().new PipelineInfo_(); + tv.pipelineName = (String)fromJSON(Type.String,obj.get("pipelineName")); + tv.pipeline = (Pipeline)fromJSON(Type.Pipeline,obj.get("pipeline")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case RenderJob: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "RenderJob": { + RenderJob.RenderJob_ tv = new RenderJob().new RenderJob_(); + tv.meshes = (ArrayList)fromJSON(Type.Array_Mesh,obj.get("meshes")); + tv.textures = (ArrayList)fromJSON(Type.Array_String,obj.get("textures")); + tv.schema = (PipelineSchema)fromJSON(Type.PipelineSchema,obj.get("schema")); + tv.scenes = (ArrayList)fromJSON(Type.Array_Scene,obj.get("scenes")); + tv.pipelines = (ArrayList)fromJSON(Type.Array_PipelineInfo,obj.get("pipelines")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case FrameResult: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "FrameResult": { + FrameResult.FrameResult_ tv = new FrameResult().new FrameResult_(); + tv.frRenderTimes = (ArrayList)fromJSON(Type.Array_Float,obj.get("frRenderTimes")); + tv.frImageWidth = (Integer)fromJSON(Type.Int,obj.get("frImageWidth")); + tv.frImageHeight = (Integer)fromJSON(Type.Int,obj.get("frImageHeight")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + case RenderJobResult: { + JSONObject obj = (JSONObject)rawObj; + String tag = obj.getString("tag"); + switch (tag) { + case "RenderJobResult": { + RenderJobResult.RenderJobResult_ tv = new RenderJobResult().new RenderJobResult_(); + tv._0 = (FrameResult)fromJSON(Type.FrameResult,obj.get("arg0")); + return tv; + } + case "RenderJobError": { + RenderJobResult.RenderJobError_ tv = new RenderJobResult().new RenderJobError_(); + tv._0 = (String)fromJSON(Type.String,obj.get("arg0")); + return tv; + } + default: throw new Exception("unknown constructor: " + tag); + } + } + } + throw new Exception("unknown type"); + } +} \ No newline at end of file diff --git a/ddl/out/java/TestData/PipelineInfo.java b/ddl/out/java/TestData/PipelineInfo.java new file mode 100644 index 0000000..6171080 --- /dev/null +++ b/ddl/out/java/TestData/PipelineInfo.java @@ -0,0 +1,26 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class PipelineInfo { + public enum Tag { + PipelineInfo + } + public Tag tag; + + public class PipelineInfo_ extends PipelineInfo { + public String pipelineName; + public Pipeline pipeline; + public PipelineInfo_() { tag = PipelineInfo.Tag.PipelineInfo; } + } +} + diff --git a/ddl/out/java/TestData/RenderJob.java b/ddl/out/java/TestData/RenderJob.java new file mode 100644 index 0000000..523cf47 --- /dev/null +++ b/ddl/out/java/TestData/RenderJob.java @@ -0,0 +1,29 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class RenderJob { + public enum Tag { + RenderJob + } + public Tag tag; + + public class RenderJob_ extends RenderJob { + public ArrayList meshes; + public ArrayList textures; + public PipelineSchema schema; + public ArrayList scenes; + public ArrayList pipelines; + public RenderJob_() { tag = RenderJob.Tag.RenderJob; } + } +} + diff --git a/ddl/out/java/TestData/RenderJobResult.java b/ddl/out/java/TestData/RenderJobResult.java new file mode 100644 index 0000000..8a55fca --- /dev/null +++ b/ddl/out/java/TestData/RenderJobResult.java @@ -0,0 +1,30 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class RenderJobResult { + public enum Tag { + RenderJobResult, + RenderJobError + } + public Tag tag; + + public class RenderJobResult_ extends RenderJobResult { + public FrameResult _0; + public RenderJobResult_() { tag = RenderJobResult.Tag.RenderJobResult; } + } + public class RenderJobError_ extends RenderJobResult { + public String _0; + public RenderJobError_() { tag = RenderJobResult.Tag.RenderJobError; } + } +} + diff --git a/ddl/out/java/TestData/Scene.java b/ddl/out/java/TestData/Scene.java new file mode 100644 index 0000000..ef60dde --- /dev/null +++ b/ddl/out/java/TestData/Scene.java @@ -0,0 +1,28 @@ +// generated file, do not modify! +// 2016-03-21T11:41:52.508392000000Z + +package TestData; + +import java.util.ArrayList; +import java.util.HashMap; +import RT.*; + +import LambdaCube.IR.*; +import LambdaCube.Mesh.*; +import LambdaCube.PipelineSchema.*; + +public class Scene { + public enum Tag { + Scene + } + public Tag tag; + + public class Scene_ extends Scene { + public HashMap> objectArrays; + public Integer renderTargetWidth; + public Integer renderTargetHeight; + public ArrayList frames; + public Scene_() { tag = Scene.Tag.Scene; } + } +} + diff --git a/ddl/templates/data.cs.ede b/ddl/templates/data.cs.ede index c88d41c..13d20f9 100644 --- a/ddl/templates/data.cs.ede +++ b/ddl/templates/data.cs.ede @@ -1,27 +1,201 @@ // generated file, do not modify! // {{ dateTime }} +using System; +using System.Linq; using System.Collections.Generic; +using Newtonsoft.Json.Linq; {% for m in imports %} using {{ m.value }}; {% endfor %} -{% for t in dataAndType %} -{% case t.value | constType %} -{% when "DataDef" %} -class {{ t.value.dataName }} { - public enum Tag { {% for c in t.value.constructors %} - {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %} - }; - public Tag tag; -}; - -namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %} - class {{ c.value.name }} : global::{{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %} - public {{ f.value.fieldType | csType }} {{ f.value.fieldName }};{% else %} - public {{ f.value.fieldType | csType | parens }} _{{ f.index0 }};{% endif %}{% endfor %} - };{% endif %}{% endfor %} +namespace {{ moduleName }} { + {% for t in dataAndType %} + {% case t.value | constType %} + {% when "DataDef" %} + class {{ t.value.dataName }} { + public enum Tag { {% for c in t.value.constructors %} + {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %} + }; + public Tag tag; + }; + + namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | empty) %} + class {{ c.value.name }} : {{ moduleName }}.{{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %} + public {{ f.value.fieldType | csType }} {{ f.value.fieldName }};{% else %} + public {{ f.value.fieldType | csType | parens }} _{{ f.index0 }};{% endif %}{% endfor %} + public {{ c.value.name }}() { tag = {{ moduleName }}.{{ t.value.dataName }}.Tag.{{ c.value.name }}; } + };{% endif %}{% endfor %} + } + {% endcase %} + {% endfor %} + + // JSON deserializer + enum Type { {% for t in usedTypes %} + {{ t.value | csTypeEnum }}{% if !t.last %},{% endif %}{% endfor %} + } + + class Loader { + public static object fromJSON(Type type, JToken obj) { + switch (type) { + {% for t in usedTypes %} + {% case t.value.tag %} + {% when "Data" %} + {% when "V2" %} + case Type.{{ t.value | csTypeEnum }}: + return new {{ t.value | csType }} + { x = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["x"]) + , y = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["y"]) + }; + {% when "V3" %} + case Type.{{ t.value | csTypeEnum }}: + return new {{ t.value | csType }} + { x = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["x"]) + , y = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["y"]) + , z = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["z"]) + }; + {% when "V4" %} + case Type.{{ t.value | csTypeEnum }}: + return new {{ t.value | csType }} + { x = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["x"]) + , y = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["y"]) + , z = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["z"]) + , w = ({{ t.value.type_ | csType }})fromJSON(Type.{{ t.value | csTypeEnum }},obj["w"]) + }; + {% when "Map" %} + case Type.{{ t.value | csTypeEnum }}: { + var map = new {{ t.value | csType }} (); + foreach(var i in (JObject)obj) { + map.Add( ({{ t.value.key_ | csType }})fromJSON(Type.{{ t.value.key_ | csTypeEnum }},i.Key) + , ({{ t.value.value_ | csType }})fromJSON(Type.{{ t.value.value_ | csTypeEnum }},i.Value)); + } + return map; + } + {% when "Array" %} + case Type.{{ t.value | csTypeEnum }}: return ((JArray)obj).Select(x => fromJSON (Type.{{ t.value.type_ | csTypeEnum }}, x)).ToList(); + {% when "List" %} + case Type.{{ t.value | csTypeEnum }}: return ((JArray)obj).Select(x => fromJSON (Type.{{ t.value.type_ | csTypeEnum }}, x)).ToList(); + {% when "Maybe" %} + case Type.{{ t.value | csTypeEnum }}: { + var m = new {{ t.value | csType }} (); + if (obj == null || obj.Type == JTokenType.Null) { + m.valid = false; + } else { + m.valid = true; + m.data = ({{ t.value.type_ | csType }})fromJSON (Type.{{ t.value.type_ | csTypeEnum }},obj); + } + return m; + } + {% else %} + case Type.{{ t.value | csTypeEnum }}: return ({{ t.value | csType }})obj; + {% endcase %} + {% endfor %} + + {% for t in definitions %} + case Type.{{ t.value.dataName }}: { + string tag = (string)obj["tag"]; + {{ t.value.dataName }}.Tag tagType; + {% for c in t.value.constructors %} + {% if !c.first %}else {% endif %}if (tag == "{{ c.value.name }}") { + tagType = {{ t.value.dataName }}.Tag.{{ c.value.name }}; + {% if !(c.value.fields | empty) %} + data.{{ c.value.name }} tv = new data.{{ c.value.name }}();{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %} + tv.{{ f.value.fieldName }} = ({{ f.value.fieldType | csType }})fromJSON(Type.{{ f.value.fieldType | csTypeEnum }},obj["{{ f.value.fieldName }}"]);{% else %} + tv._{{ f.index0 }} = ({{ f.value.fieldType | csType }})fromJSON(Type.{{ f.value.fieldType | csTypeEnum }},obj["arg{{ f.index0 }}"]);{% endif %}{% endfor %} + return tv; + {% endif %} + } + {% endfor %} + else throw new Exception("unknown constructor: " + tag); + {{ t.value.dataName }} o = new {{ t.value.dataName }}(); + o.tag = tagType; + return o; + } + {% endfor %} + } + throw new Exception("unknown type"); + return null; + } + + {% for t in definitions %} + JToken toJSON({{ t.value.dataName }} v) { + var obj = new JObject(); + switch (v.tag) { {% for c in t.value.constructors %} + case {{ t.value.dataName }}.Tag.{{ c.value.name }}: + obj["tag"] = "{{ c.value.name }}";{% if !(c.value.fields | empty) %} + { + var tv = (data.{{ c.value.name }})v;{% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %} + obj["{{ f.value.fieldName }}"] = toJSON(tv.{{ f.value.fieldName }});{% else %} + obj["arg{{ f.index0 }}"] = toJSON(tv._{{ f.index0 }});{% endif %}{% endfor %} + }{% endif %} + break;{% endfor %} + } + return obj; + } + {% endfor %} + + {% for t in usedCSTypes %} + {% case t.value.tag %} + {% when "Data" %} + {% when "V2" %} + JToken toJSON({{ t.value | csType }} v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + return obj; + } + {% when "V3" %} + JToken toJSON({{ t.value | csType }} v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + return obj; + } + {% when "V4" %} + JToken toJSON({{ t.value | csType }} v) { + var obj = new JObject(); + obj["x"] = toJSON(v.x); + obj["y"] = toJSON(v.y); + obj["z"] = toJSON(v.z); + obj["w"] = toJSON(v.w); + return obj; + } + {% when "Maybe" %} + JToken toJSON({{ t.value | csType }} v) { + if (v.valid) { + return toJSON(v.data); + } + return new JValue((string)null); + } + {% when "Map" %} + JToken toJSON({{ t.value | csType }} v) { + var obj = new JObject(); + foreach (var i in v) { + obj[i.Key] = toJSON(i.Value); + } + return obj; + } + {% when "Array" %} + JToken toJSON({{ t.value | csType }} v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + {% when "List" %} + JToken toJSON({{ t.value | csType }} v) { + var obj = new JArray(); + foreach (var i in v) { + obj.Add(toJSON(i)); + } + return obj; + } + {% else %} + JToken toJSON({{ t.value | csType }} v) { return new JValue(v); } + {% endcase %} + {% endfor %} + } } -{% endcase %} -{% endfor %} diff --git a/ddl/templates/data.hpp.ede b/ddl/templates/data.hpp.ede index dab478c..5220cf4 100644 --- a/ddl/templates/data.hpp.ede +++ b/ddl/templates/data.hpp.ede @@ -30,7 +30,7 @@ namespace data { {% for c in t.value.constructors %}{% if !(c.value.fields | emp {% when "TypeAlias" %} {% case t.value.aliasType.tag %} {% when "Data" %} -typedef {{ t.value.aliasType.contents }} {{ t.value.aliasName }}; +typedef {{ t.value.aliasType.name_ }} {{ t.value.aliasName }}; {% else %} typedef {{ t.value.aliasType | cppType }} {{ t.value.aliasName }}; {% endcase %} diff --git a/ddl/templates/data.hpp2.ede b/ddl/templates/data.hpp2.ede index b28562d..7ae1b13 100644 --- a/ddl/templates/data.hpp2.ede +++ b/ddl/templates/data.hpp2.ede @@ -34,7 +34,7 @@ public: {% when "TypeAlias" %} {% case t.value.aliasType.tag %} {% when "Data" %} -typedef {{ t.value.aliasType.contents }} {{ t.value.aliasName }}; +typedef {{ t.value.aliasType.name_ }} {{ t.value.aliasName }}; {% else %} typedef {{ t.value.aliasType | cppType }} {{ t.value.aliasName }}; {% endcase %} diff --git a/ddl/templates/data.java.ede b/ddl/templates/data.java.ede index c85a521..2aec628 100644 --- a/ddl/templates/data.java.ede +++ b/ddl/templates/data.java.ede @@ -1,26 +1,27 @@ // generated file, do not modify! // {{ dateTime }} +package {{ moduleName }}; + +import java.util.ArrayList; +import java.util.HashMap; + {% for m in imports %} -import {{ m.value }}; +import {{ m.value }}.*; {% endfor %} -public class {{ moduleName }} { -{% for t in dataAndType %} -{% case t.value | constType %} +{% case def | constType %} {% when "DataDef" %} - public class {{ t.value.dataName }} { - public enum Tag { {% for c in t.value.constructors %} - {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %} - } - public Tag tag; -{% for c in t.value.constructors %}{% if !(c.value.fields | empty) %} - public class {{ c.value.name }}_ extends {{ t.value.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %} - public {{ f.value.fieldType | javaType }} {{ f.value.fieldName }};{% else %} - public {{ f.value.fieldType | javaType }} _{{ f.index0 }};{% endif %}{% endfor %} - }{% endif %}{% endfor %} +public class {{ def.dataName }} { + public enum Tag { {% for c in def.constructors %} + {{ c.value.name }}{% if !c.last %},{% endif %}{% endfor %} } + public Tag tag; +{% for c in def.constructors %}{% if !(c.value.fields | empty) %} + public class {{ c.value.name }}_ extends {{ def.dataName }} { {% for f in c.value.fields %}{% if c.value.fields | hasFieldNames %} + public {{ f.value.fieldType | javaType }} {{ f.value.fieldName }};{% else %} + public {{ f.value.fieldType | javaType }} _{{ f.index0 }};{% endif %}{% endfor %} + }{% endif %}{% endfor %} +} {% endcase %} -{% endfor %} -} \ No newline at end of file -- cgit v1.2.3