h$v      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         #None# GPipe-CoreRun a subcomputation in a scope, where nothing memoized inside will be remembered afterNone$None #$&'(>?2 GPipe-CoreProvides a common way to convert numeric types to integer and floating point representations. GPipe-Core#Convert to a floating point number. GPipe-Core=Convert to an integral number, using truncation if necessary. GPipe-CoreConvert to an unsigned integral number, using truncation if necessary. GPipe-Core5This class provides various order comparing functions GPipe-CoreThis class provides the GPU functions either not found in Prelude's numerical classes, or that has wrong types. Instances are also provided for normal s and s. GPipe-CoreConstraint for types that may pass in and out of shader control structures. Define your own instances in terms of others and make sure to make toBase as lazy as possible. GPipe-Core5A base type that this type can convert into. Use the % function on an existing instance of ! to define this in your instance. GPipe-CoreConvert this type to the shader base type. Make sure this is as lazy as possible (e.g. use tilde (~) on each pattern match). GPipe-Core4Convert back from the shader base type to this type. GPipe-CoreAn opaque type GPipe-CoreWe reuse V for geometry shader, which simplify things and makes sense save the GenerativeGeometry@ GPipe-Core'Phantom type used as first argument in   a7 that denotes that the shader value is a fragment value GPipe-Core'Phantom type used as first argument in   a5 that denotes that the shader value is a vertex value GPipe-Core&The shader GLSL source to be compiled. GPipe-Core!The uniforms used in this shader. GPipe-Core!The samplers used in this shader. GPipe-Core(The input variables used in this shader. GPipe-CoreThe output declations to include in the previous shader to provide the needed input variables. GPipe-CoreThe expression to evaluate in order to produce the previous shader. GPipe-CoreWorks just like %, return second argument if first is ! otherwise return third argument.The difference from < is that it in most cases generate more efficient code when a is a compound type (e.g. a tuple or a vector). For simple types such as  S x Float, ifThenElse' == ifB. GPipe-CoreifThenElse c f g x will return f x if c evaluates to  or g x otherwise.)In most cases functionally equivalent to  but usually generate smaller shader code since the last argument is not inlined into the two branches, which also would affect implicit derivates (e.g. ,  or sampling using  SampleAuto) GPipe-Core ifThen c f x will return f x if c evaluates to  or x otherwise.)In most cases functionally equivalent to  but usually generate smaller shader code since the last argument is not inlined into the two branches, which also would affect implicit derivates (e.g. ,  or sampling using  SampleAuto) GPipe-Core while f g x will iteratively transform x with g as long as f generates . GPipe-CoreThe derivative in x using local differencing of the rasterized value. GPipe-CoreThe derivative in y using local differencing of the rasterized value. GPipe-CoreThe sum of the absolute derivative in x and y using local differencing of the rasterized value.None699None  '(>?7None '(3>?K GPipe-CoreThis kind of exception may be thrown from GPipe when a GPU hardware limit is reached (for instance, too many textures are drawn to from the same FragmentStream) GPipe-Core!A monad in which shaders are run. GPipe-CoreThe monad transformer that encapsulates a GPipe context (which wraps an OpenGl context).A value of type ContextT ctx os m a1 is an action on a context with these parameters: ctxThe context handler.osAn abstract type that is used to denote the object space. This is an forall type defined by the  call which will restrict any objects created inside this context to be returned from it or used by another context (the same trick as the ST monad uses).m5The monad this monad transformer wraps. Need to have  in the bottom for this  to be runnable.a*The value returned from this monad action. GPipe-CoreClass implementing a window handler that can create openGL contexts, such as GLFW or GLUT GPipe-CoreImplementation specific context handler parameters, eg error handling and event processing policies GPipe-Core#Implementation specific window type GPipe-CoreImplementation specific window parameters, eg initial size and border decoration GPipe-Core5Create a context handler. Called from the main thread GPipe-CoreDelete the context handler. All contexts created from this handler will be deleted using contextDelete prior to calling this. GPipe-CoreCreate a new context sharing all other contexts created by this ContextHandler. If the parameter is Nothing, a hidden off-screen context is created, otherwise creates a window with the provided window bits and implementation specific parameters. Only ever called from the mainthread (i.e. the thread that called contextHandlerCreate). GPipe-CoreRun an OpenGL IO action in this context, that doesn't return any value to the caller. This may be run after contextDelete or contextHandlerDelete has been called. The thread calling this may not be the same creating the context (for finalizers it is most definetly not). May also be called on previously deleted windows in the case of finalizers. GPipe-CoreSwap the front and back buffers in the context's default frame buffer. Only ever called from the mainthread (i.e. the thread that called &). Never called on deleted windows. GPipe-CoreGet the current size of the context's default framebuffer (which may change if the window is resized). Only ever called from the mainthread (i.e. the thread that called ) GPipe-CoreDelete a context and close any associated window. Only ever called from the mainthread (i.e. the thread that called ). Only ever called once per window, and will always be called for each window before the context is deleted with . GPipe-CoreRun a  monad, that may have the effect of windows or textures being drawn to. May throw a  if a combination of draw images (FBO) used by this render call is unsupported by the graphics driver GPipe-CoreRun a  monad transformer that encapsulates an object space. You need an implementation of a 5, which is provided by an auxillary package, such as  GPipe-GLFW. GPipe-CoreCreates a window GPipe-CoreDeletes a window. Any rendering to this window will become a noop. GPipe-CoreRun this action after a  call to swap out the context windows back buffer with the front buffer, effectively showing the result. This call may block if vsync is enabled in the system and/or too many frames are outstanding. After this call, the context window content is undefined and should be cleared at earliest convenience using clearContextColor and friends. GPipe-CoreReturn the current size of the context frame buffer. This is needed to set viewport size and to get the aspect ratio to calculate projection matrices. GPipe-CoreUse the context window handle, which type is specific to the window system used. This handle shouldn't be returned from this function GPipe-CoreRemoves a VAO entry from all SharedContextDatas when one of the buffers are deleted. This will in turn make the VAO finalizer to be run. GPipe-CoreRemoves a FBO entry from all SharedContextDatas when one of the textures are deleted. This will in turn make the FBO finalizer to be run.NoneM GPipe-CoreMay throw a GPipeException The multiple drawcalls to be compiled are intended to use the same environment s? (and only one is selected dynamically when rendering). public GPipe-CoreA whenJust/ that accepts a monoidal return value. private,,None >?[e GPipe-CoreThis type family restricts what host and buffer types a texture format may be converted into. 'BufferColor t h' for a texture representation t and a host representation h will evaluate to a buffer type used in the transfer. This family is closed, i.e. you cannot create additional instances to it. GPipe-CoreThis works like a 'B a', but has an alignment smaller than 4 bytes that is the limit for vertex buffers, and thus cannot be used for those. Index buffers on the other hand need to be tightly packed, so you need to use this type for index buffers of  or . GPipe-CoreThis wrapper is used for integer values to indicate that it should be interpreted as a floating point value, in the range [-1,1] or [0,1] depending on wether it is a signed or unsigned integer (i.e.  or ). GPipe-CoreAny buffer value that is going to be used as a uniform needs to be wrapped in this newtype. This will cause is to be aligned properly for uniform usage. It can still be used as input for vertex arrays, but due to the uniform alignment it will probably be padded quite heavily and thus wasteful. GPipe-Core5An atomic buffer value that represents a vector of 4 as on the host. This works similar to '(B a, B a, B a, B a)' but has some performance advantage, especially when used in  VertexArrays. GPipe-Core5An atomic buffer value that represents a vector of 3 as on the host. GPipe-Core5An atomic buffer value that represents a vector of 2 as on the host. GPipe-Core=The atomic buffer value that represents a host value of type a. GPipe-CoreThe arrow type for . GPipe-CoreA  Buffer os b lives in the object space os and contains elements of type b. GPipe-Core,Retrieve the number of elements in a buffer. GPipe-Core do ... GPipe-Core Split up a  a into two  as. GPipe-Core Discard the last component of a  a to get a  a. GPipe-Core Split up a  a into a  a and a B1 a. GPipe-Core Split up a  a into a B1 a and a  a. GPipe-Core Split up a  a into two B1 as. GPipe-Core4Create a buffer with a specified number of elements. GPipe-Core=Write a buffer from the host (i.e. the normal Haskell world). GPipe-Core?e GPipe-CoreA compiled shader is just a function that takes an environment and returns a " action It could have been called CompiledDrawcall or Renderer because it is the same thing. GPipe-CoreThe monad in which all GPU computations are done. 'Shader os s a' lives in an object space os and a context with format f&, closing over an environent of type s. GPipe-CoreMap the environment to a different environment and run a Shader in that sub environment, returning it's result. GPipe-Core1Conditionally run the effects of a shader when a  value is  something. GPipe-CoreSelect one of two  actions based on whether an  value is  or . GPipe-CoreDiscard all effects of a  action (i.e., dont draw anything) and just return the resulting value. GPipe-CoreLike guard, but dependent on the Shaders environment value. Since this will be evaluated at shader run time, as opposed to shader compile time for guard', using this to do recursion will make  diverge. You can break that divergence by combining it with a normal guard and a maximum loop count. GPipe-CoreCompiles a shader into a . This action will usually take a second or more, so put it during a loading sequence or something. May throw a GPipeException if the graphics driver doesn't support something in this shader (e.g. too many interpolated floats sent between a vertex and a fragment shader) None  '(>pr GPipe-CoreAn array of primitives GPipe-CoreAn index array is like a vertex array, but contains only integer indices. These indices must come from a tightly packed , hence the lack of a ! instance and no conversion from s. GPipe-CoreNumer of indices in an . GPipe-Core"A phantom type to indicate that a $ may only be used for instances (in  and ). GPipe-CoreA vertex array is the basic building block for a primitive array. It is created from the contents of a , but unlike a , it may be truncated, zipped with other vertex arrays, and even morphed into arrays of a different type with the provided  instance. A VertexArray t a has elements of type a, and t indicates whether the vertex array may be used as instances or not. GPipe-Core%Retrieve the number of elements in a . GPipe-Core Create a  from a . The vertex array will have the same number of elements as the buffer, use  and  to make it smaller. GPipe-CoreZip two s using the function given as first argument. If either of the argument s are restriced to  only, then so will the resulting array be, as depicted by the  type family. GPipe-CoretakeVertices n a. creates a shorter vertex array by taking the n first elements of the array a. GPipe-CoredropVertices n a0 creates a shorter vertex array by dropping the n first elements of the array a. The argument array a$ must not be constrained to only . GPipe-CorereplicateEach n a will create a longer vertex array, only to be used for instances, by replicating each element of the array a n times. E.g. replicateEach 3 {ABCD...} will yield {AAABBBCCCDDD...}. This is particulary useful before zipping the array with another that has a different replication rate. GPipe-Core Create an  from a 4 of unsigned integers (as constrained by the closed  type family instances). The index array will have the same number of elements as the buffer, use  and  to make it smaller. The Maybe a argument is used to optionally denote a primitive restart index. GPipe-CoretakeIndices n a- creates a shorter index array by taking the n first indices of the array a. GPipe-CoredropIndices n a/ creates a shorter index array by dropping the n first indices of the array a.; None '(>?u& GPipe-CoreA texture image is a reference to a 2D array of pixels in a texture. Some textures contain one 0 per level of detail while some contain several. GPipe-Core.The type of a color sample made by a texture t GPipe-CoreFor some reason, OpenGl doesnt allow explicit lod to be specified for some sampler types, hence this extra GADT. GPipe-CoreA GADT to specify where the level of detail and/or partial derivates should be taken from. Some values of this GADT are restricted to only FragmentStreams.  GPipe-CoreUsed instead of  for shadow samplers. These samplers have specialized sampler values, see   and friends.  GPipe-Core!A GADT for sample filters, where  % cannot be used for integer textures.  GPipe-Core9Compare two images that doesn't necessarily has same type  GPipe-CoreRetrieve the 2D size an image     None '(>?|  GPipe-CoreThe arrow type for  .  GPipe-CoreThis class constraints which buffer types can be loaded as uniforms, and what type those values have.  GPipe-CoreThe type the buffer value will be turned into once it becomes a vertex or fragment value (the x parameter is either V or F).  GPipe-CoreAn arrow action that turns a value from it's buffer representation to it's vertex or fragment representation. Use   from the GPipe provided instances to operate in this arrow. Also note that this arrow needs to be able to return a value lazily, so ensure you useproc ~pattern -> do ....  GPipe-CoreLoad a uniform value from a  into a . The argument function is used to retrieve the buffer and the index into this buffer from the shader environment. UBO are obviously used here and there is no way to use "classic" uniform. None >?  GPipe-CoreThe arrow type for  .  GPipe-CoreThis class constraints which buffer types can be turned into vertex values, and what type those values have.  GPipe-CoreThe type the buffer value will be turned into once it becomes a vertex value.  GPipe-CoreAn arrow action that turns a value from it's buffer representation to it's vertex representation. Use   from the GPipe provided instances to operate in this arrow. Also note that this arrow needs to be able to return a value lazily, so ensure you useproc ~pattern -> do ....  GPipe-CoreA   t a $ is a stream of primitives of type t' where the vertices are values of type a8. You can operate a stream's vertex values using the  instance (this will result in a shader running on the GPU). You may also append   s using the - instance, but if possible append the origin ?  GPipe-CoreA float value that doesn't get divided by the interpolated position's w-component during interpolation.  GPipe-CoreA float value that is not interpolated (like integers), and all fragments will instead get the value of the primitive's last vertex  GPipe-CoreThe fragment depth range to map the canonical view volume's z-coordinate to. Depth values are clamped to [0,1], so DepthRange 0 1 gives maximum depth resolution.  GPipe-CoreThe viewport in pixel coordinates (where (0,0) is the lower left corner) in to which the canonical view volume [(-1,-1,-1),(1,1,1)] is transformed and clipped/scissored.  GPipe-CoreDefines whether to fill the polygon or to show points or wireframes.  GPipe-CoreDefines which side to rasterize. Non triangle primitives only has a front side.  GPipe-CoreThis class constraints which vertex types can be turned into fragment values, and what type those values have.  GPipe-CoreThe type the vertex value will be turned into once it becomes a fragment value.  GPipe-CoreAn arrow action that turns a value from it's vertex representation to it's fragment representation. Use   from the GPipe provided instances to operate in this arrow. Also note that this arrow needs to be able to return a value lazily, so ensure you useproc ~pattern -> do ....  GPipe-CoreThe arrow type for  .  GPipe-CoreA   a " is a stream of fragments of type a. You may append   s using the > instance, and you can operate a stream's values using the < instance (this will result in a shader running on the GPU).  GPipe-Core9Rasterize a stream of primitives into fragments, using a  ,  , Viewport and   from the shader environment. Primitives will be transformed from canonical view space, i.e. [(-1,-1,-1),(1,1,1)], to the 2D space defined by the  1 parameter and the depth range defined by the   parameter.   controls whether to fill in the primitives or whether to show a wireframe or points only.  GPipe-CoreFilter out fragments from the stream where the predicate in the first argument evaluates to ", and discard all other fragments.  GPipe-CoreLike , but where various auto generated information from the rasterization is provided for each vertex.+ + None  '(>, , None '(>?  None  None "  GPipe-CoreDenotes the operation that will be performed on the target's stencil value  GPipe-CoreA bitwise logical operation that will be used to combine colors that has an integral internal representation.  GPipe-CoreA factor that the source (fragment) or the destination (target) will be multiplied with before combined with the other in the  .  GPipe-CoreThe equation used to combine the source (fragment) and the destination (target) after they have been multiplied with their respective  s.  GPipe-CoreA set of blending factors used for the source (fragment) and the destination (target).  GPipe-CoreDenotes how each fragment's color value should be blended with the target value.  GPipe-Core:The fragment's color will simply replace the target value.  GPipe-CoreThe fragment's color will be blended using an equation and a set of factors for the RGB components, and a separate equation and set of factors for the Alpha component (if present), and a  ! that may be referenced from the  . The   may be  if none of the   needs it. This kind of blending will only be made on colors with a  representation (e.g. RGB8 or RGB32F , but not RGB8I7), integer colors will simply replace the target value.  GPipe-CoreA logical operation that will be done on the bits of the fragment color and the target color. This kind of blending is only done on colors that has a integral internal representation (e.g. RGB8 or RGB8I , but not RGB32F; note the difference with  BlendRgbAlpha restriction). For targets with an internal floating point representation, the fragment value will simply replace the target value.  GPipe-Core1Indicates whether this color draw should use the  . setting given to the draw action. If this is , the fragment's color value will simply replace the target value.  GPipe-CoreThe function used to compare the fragment's depth and the depth buffers depth with. E.g. Less means "where fragment's depth is less than the buffers current depth".  GPipe-Core8 if the depth component should be written to the target.  GPipe-Core? for each color component that should be written to the target.  GPipe-Core6A monad in which individual color images can be drawn. GPipe-Core8Draw color values into a color renderable texture image. GPipe-CoreDraw all fragments in a   using the provided function that passes each fragment value into a  = monad. The first argument is a function that retrieves a   setting from the shader environment, which will be used for all  actions in the   monad where   is . (OpenGl 3.3 unfortunately doesn't support having different blending settings for different color targets.) GPipe-CoreLike 8, but performs a depth test on each fragment first. The   monad is then only run for fragments where the depth test passes. GPipe-CoreLike :, but performs a stencil test on each fragment first. The   monad is then only run for fragments where the stencil test passes. GPipe-CoreLike , but performs a stencil test and a depth test (in that order) on each fragment first. The   monad is then only run for fragments where the stencil and depth test passes. GPipe-CoreDraw color values from a   into the window. GPipe-Core.Perform a depth test for each fragment from a   in the window. This doesn't draw any color values and only affects the depth buffer. GPipe-Core.Perform a depth test for each fragment from a   and write a color value from each fragment that passes the test into the window. GPipe-Core0Perform a stencil test for each fragment from a   in the window. This doesn't draw any color values and only affects the stencil buffer. GPipe-Core0Perform a stencil test for each fragment from a   and write a color value from each fragment that passes the test into the window. GPipe-CorePerform a stencil test and depth test (in that order) for each fragment from a   in the window. This doesnt draw any color values and only affects the depth and stencil buffer. GPipe-CorePerform a stencil test and depth test (in that order) for each fragment from a   and write a color value from each fragment that passes the tests into the window. GPipe-Core.Fill a color image with a constant color value GPipe-CoreFill a depth image with a constant depth value (in the range [0,1]) GPipe-Core0Fill a depth image with a constant stencil value GPipe-CoreFill a combined depth stencil image with a constant depth value (in the range [0,1]) and a constant stencil value GPipe-Core9Fill the window's back buffer with a constant color value GPipe-CoreFill the window's back depth buffer with a constant depth value (in the range [0,1]) GPipe-CoreFill the window's back stencil buffer with a constant stencil value GPipe-CoreFill the window's back depth and stencil buffers with a constant depth value (in the range [0,1]) and a constant stencil value     None+    None" "  Safe-Inferred   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLONMPQRSTUVWXYZ[\]^`_cbagdfeihjklmnopqrstuvwxyz{|}~   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLONMPQRSTUVWXYZ[\]^`_cbagdfeihjklmnopqrstuvwxyz{|}~ Safe-InferredNone5/None  None   Nonej   None !None  "None  #None<   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLONMPQRSTUVWXYZ[\]^`_cbagdfeihjklmnopqrstuvwxyz{|}~ $%&$%'$%($%($)*$)+$),$)-$).$)/$)0$)1$)2$)3$45$46$47$48$49$4:$4;$4<$=>$=?$=@$=A$=B$=C$=D$=E$=F$=G$=H$=I$=J$=K$=L$=M$=N$=O$=P$=Q$=R$=S$=T$=U$=V$=W$=X$=Y$=Z$=[$=\$=]$=^$=_$=`$=a$=b$=c$=d$=e$=f$=g$=h$=i$=j$=k$=l$=m$=n$=o$=p$=q$=r$=s$tu$tv$tw$tx$yz$y{$y|$y}$y~$y$y$y$y$y$y$y$y$y$y$y$y$y$y$y$y$y$y$y$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              GPipe-Core-0.2.3.1-inplaceGraphics.GPipe.LinearGraphics.GPipe.Internal.DebugGraphics.GPipe.Internal.ExprGraphics.GPipe.Internal.FormatGraphics.GPipe.Internal.Context Graphics.GPipe.Internal.CompilerGraphics.GPipe.Internal.BufferGraphics.GPipe.Internal.LinearGraphics.GPipe.Internal.OrphansGraphics.GPipe.Internal.Shader&Graphics.GPipe.Internal.PrimitiveArrayGraphics.GPipe.Internal.TextureGraphics.GPipe.Internal.Uniform'Graphics.GPipe.Internal.PrimitiveStream&Graphics.GPipe.Internal.FragmentStream&Graphics.GPipe.Internal.GeometryStream)Graphics.GPipe.Internal.TransformFeedback#Graphics.GPipe.Internal.FrameBuffer Data.SNMapGraphics.GPipe.ExprGraphics.GPipe.BufferGraphics.GPipe.ContextGraphics.GPipe.FormatGraphics.GPipe.GeometryStreamGraphics.GPipe.FrameBufferGraphics.GPipe.FragmentStreamGraphics.GPipe.OrphansGraphics.GPipe.PrimitiveArrayGraphics.GPipe.PrimitiveStreamGraphics.GPipe.SamplerGraphics.GPipe.ShaderGraphics.GPipe.Texture Graphics.GPipe.TransformFeedbackGraphics.GPipe.UniformGraphics.GPipe6linear-1.21.5-4f98bd9e78dc4cb78ff50f4b82d11b37d063fafeLinear.Covector$* runCovectorCovectorLinear.Algebra counitalRep comultRep unitalRepmultRepunitalmultAlgebracounitalcomult CoalgebraLinear.Projection inverseOrthoorthoinverseInfinitePerspectiveinfinitePerspectiveinverseFrustumfrustuminversePerspective perspective Linear.Matrix luDetFiniteluDet luInvFiniteluInv luSolveFiniteluSolvebackwardSubFinite backwardSubforwardSubFinite forwardSubluFiniteluinv44 transposeinv33inv22det44det33det22_m44_m43_m42_m34_m33_m32_m24_m23_m22 translationidentity m33_to_m44 m43_to_m44mkTransformationmkTransformationMatfromQuaternionadjoint!!/!!**!!*!!*!-!!+!!*!columnM22M23M24M32M33M34M42M43M44 Linear.Trace frobeniusdiagonaltraceTraceLinear.Quaternion axisAnglerotateslerpatanhqacoshqasinhqatanqacosqasinqpowabsiekejeiee Quaternion_i_e Complicated_ijk_k_j Hamiltonian Linear.V0V0 Linear.V4normalizePointpointvectorew_wzyx_wzxy_wyzx_wyxz_wxzy_wxyz_zwyx_zwxy_zywx_zyxw_zxwy_zxyw_ywzx_ywxz_yzwx_yzxw_yxwz_yxzw_xwzy_xwyz_xzwy_xzyw_xywz_wzy_wzx_wyz_wyx_wxz_wxy_zwy_zwx_zyw_zxw_ywz_ywx_yzw_yxw_xwz_xwy_xzw_xyw_wz_wy_wx_zw_yw_xwV4_xyzw_wR4 Linear.V3triplecrossez_zyx_zxy_yzx_yxz_xzy_zy_zx_yz_xzV3_xyz_zR3 Linear.V2crossZunangleangleperpey_yxV2_xy_yR2 Linear.V1exV1_xR1 Linear.Metricproject normalizesignormnormdistanceqd quadrancedotMetric Linear.VectorouterunitscaledbasisForbasis^/^**^sumVnegatedelEliftI2liftU2lerp^-^^+^zeroAdditiveLinear.EpsilonnearZeroEpsilonLinear.Conjugate conjugate ConjugateTrivialConjugate Linear.Binary getLinear putLineartraceIt traceList checkGlErrorgetErrorMessageConvert ConvertFloat ConvertInt ConvertWordtoFloattoInttoWord FloatingOrdclampsaturatestep smoothstepReal'rsqrtexp2log2floor'ceiling'fract'mod''mixatan2'Bits'and'or'xor' complement'shiftL'shiftR'bitSize' Integral'div'mod' ShaderTypeShaderBaseTypetoBasefromBase ShaderBaseShaderBaseFloat ShaderBaseIntShaderBaseWordShaderBaseBoolShaderBaseUnitShaderBaseProdShaderBaseGenerativeGeometryRValueFBoolFWordFIntFFloatGGenerativeGeometryVBoolVWordVIntVFloatGenerativeGeometryGFVSunSShaderStageOutputsourceuniformssamplersinputspreviousDeclarationsprevExpressionShaderStageInputoutputDeclarations expression ExprResult finalSourceunissampsinps prevDeclsprevSs ShaderInputsshaderUsedUniformBlocksshaderUsedSamplersshaderUsedInputshaderGeometry ExprState GlobDeclMExprMSType STypeFloatSTypeInt STypeBool STypeUIntSTypeDynSTypeMatSTypeVec STypeIVec STypeUVecSTypeGenerativeGeometry NextGlobal NextTempVartshow stypeName stypeSizerunExprMevaluateExpressionscalarSvec2Svec3Svec4SscalarS'vec2S'vec3S'vec4S'vec2S''vec3S''vec4S'' useVInput useGInputuseFInputFromG useFInputdeclareGeometryLayout useUniform useSamplergetNexttellAssignmenttellAssignment'tellSTdiscard tellGlobalLn tellGlobalshaderbaseDeclareshaderbaseAssignshaderbaseReturnshaderbaseDeclareDefshaderbaseAssignDefshaderbaseReturnDef ifThenElse' ifThenElseifThentellIfwhile errShaderTypebinfun1fun2fun3fun4postoppreopbinffun1ffun2ffun3fpreopfpostopfbinifun1ipreopibinufun1upreopudFdxdFdyfwidthfromVfromVec4fromVec3fromVec2 fromMat22 fromMat23 fromMat24 fromMat32 fromMat33 fromMat34 fromMat42 fromMat43 fromMat44mulToV4mulToV3mulToV2mulToMd2d3d4unV1outerToMlength4length3length2 normalize4 normalize3 normalize2dist4dist3dist2crossSminSmaxS mul_12_21vv mul_13_31vv mul_14_41vv mul_12_21vm mul_13_31vm mul_14_41vm mul_12_21mv mul_13_31mv mul_14_41mv mul_12_21mm mul_13_31mm mul_14_41mm mul_21_12 mul_21_13 mul_21_14 mul_31_12 mul_31_13 mul_31_14 mul_41_12 mul_41_13 mul_41_14 mul_21_12m mul_21_13m mul_21_14m mul_31_12m mul_31_13m mul_31_14m mul_41_12m mul_41_13m mul_41_14m mul_12_22 mul_13_32 mul_14_42 mul_12_23 mul_13_33 mul_14_43 mul_12_24 mul_13_34 mul_14_44 mul_12_22m mul_13_32m mul_14_42m mul_12_23m mul_13_33m mul_14_43m mul_12_24m mul_13_34m mul_14_44m mul_22_21 mul_23_31 mul_24_41 mul_32_21 mul_33_31 mul_34_41 mul_42_21 mul_43_31 mul_44_41 mul_22_21m mul_23_31m mul_24_41m mul_32_21m mul_33_31m mul_34_41m mul_42_21m mul_43_31m mul_44_41m mul_22_22 mul_23_32 mul_24_42 mul_22_23 mul_23_33 mul_24_43 mul_22_24 mul_23_34 mul_24_44 mul_32_22 mul_33_32 mul_34_42 mul_32_23 mul_33_33 mul_34_43 mul_32_24 mul_33_34 mul_34_44 mul_42_22 mul_43_32 mul_44_42 mul_42_23 mul_43_33 mul_44_43 mul_42_24 mul_43_34 mul_44_44$fTrivialConjugateS$fTrivialConjugateS0$fTrivialConjugateS1 $fConjugateS $fConjugateS0 $fConjugateS1$fIfBS$fIfBS0$fIfBS1$fIfBS2$fOrdBS$fEqBS $fBooleanS $fFloatingS $fFractionalS$fNumS$fNumS0$fNumS1$fIfBS3$fShaderType(,,,,,,)x$fShaderType(,,,,,)x$fShaderType(,,,,)x$fShaderType(,,,)x$fShaderType(,,)x$fShaderType(,)x$fShaderTypeV4x$fShaderTypeV3x$fShaderTypeV2x$fShaderTypeV1x$fShaderTypeV0x$fShaderTypeSx$fShaderType()x$fShaderTypeSx0$fShaderTypeSx1$fShaderTypeSx2$fShaderTypeSx3 $fIntegral'V4 $fIntegral'V3 $fIntegral'V2 $fIntegral'V1 $fIntegral'V0 $fIntegral'S $fIntegral'S0$fIntegral'Word8$fIntegral'Word16$fIntegral'Word32$fIntegral'Word$fIntegral'Int8$fIntegral'Int16$fIntegral'Int32$fIntegral'Int$fBits'S $fBits'S0 $fReal'V4 $fReal'V3 $fReal'V2 $fReal'V1 $fReal'V0$fReal'S $fReal'Double $fReal'Float$fFloatingOrdS$fFloatingOrdDouble$fFloatingOrdFloat $fConvertS $fConvertS0 $fConvertS1 $fConvertWord $fConvertInt$fConvertFloat WindowBits WindowFormatWindowFormatColorWindowFormatColorDepthWindowFormatColorStencil%WindowFormatColorDepthStencilSeparate%WindowFormatColorDepthStencilCombinedWindowFormatDepthWindowFormatStencil WindowFormatDepthStencilSeparate WindowFormatDepthStencilCombinedContextColorFormatredBits greenBitsblueBits alphaBitsStencilRenderableDepthRenderableColorRenderableisSrgb clearColorColorSampleableColor ColorElementtypeStrtypeStr4toColor fromColorsetBorderColor samplerPrefix TextureFormat getGlFormatFormatR8R8SR16R16SR16FR32FR8IR16IR32IR8UIR16UIR32UIRG8RG8SRG16RG16SRG16FRG32FRG8IRG16IRG32IRG8UIRG16UIRG32UIR3G3B2RGB4RGB5RGB8RGB8SRGB10RGB12RGB16RGB16SRGB16FRGB32F R11FG11FB10FRGB9E5SRGB8RGB8IRGB16IRGB32IRGBWordRGB8UIRGB16UIRGB32UIRGBA2RGBA4RGB5A1RGBA8RGBA8SRGB10A2RGBA12RGBA16RGBA16SRGBA16FRGBA32FSRGB8A8RGBA8IRGBA16IRGBA32IRGBA8UIRGBA16UIRGBA32UIDepth16Depth24Depth32Depth32FStencil1Stencil4Stencil8 Stencil16Depth24Stencil8Depth32FStencil8 DepthStencilStencilDepthRGBAWordRGBAInt RGBAFloatRGBIntRGBFloatRGWordRGIntRGFloatRWordRIntRFloatgetGlInternalFormat colorBits depthBits stencilBitsdepthStencilBits windowBits$fTextureFormatDepthStencil$fTextureFormatDepth$fTextureFormatRGBAWord$fTextureFormatRGBAInt$fTextureFormatRGBAFloat$fTextureFormatRGBWord$fTextureFormatRGBInt$fTextureFormatRGBFloat$fTextureFormatRGWord$fTextureFormatRGInt$fTextureFormatRGFloat$fTextureFormatRWord$fTextureFormatRInt$fTextureFormatRFloat$fColorSampleableDepthStencil$fColorSampleableDepth$fColorSampleableRGBAWord$fColorSampleableRGBAInt$fColorSampleableRGBAFloat$fColorSampleableRGBWord$fColorSampleableRGBInt$fColorSampleableRGBFloat$fColorSampleableRGWord$fColorSampleableRGInt$fColorSampleableRGFloat$fColorSampleableRWord$fColorSampleableRInt$fColorSampleableRFloat$fColorRenderableRGBAWord$fColorRenderableRGBAInt$fColorRenderableRGBAFloat$fColorRenderableRGBWord$fColorRenderableRGBInt$fColorRenderableRGBFloat$fColorRenderableRGWord$fColorRenderableRGInt$fColorRenderableRGFloat$fColorRenderableRWord$fColorRenderableRInt$fColorRenderableRFloat$fDepthRenderableDepthStencil$fDepthRenderableDepth$fStencilRenderableDepthStencil$fStencilRenderableStencil$fContextColorFormatRGBAFloat$fContextColorFormatRGBFloat$fContextColorFormatRGFloat$fContextColorFormatRFloatFBOKeys fboColorsfboDepth fboStencilFBOKeyfboTnamefboTlayerOrNegIfRendBuff fboTlevelVAOKeyvaoBnamevaoCombBufferOffset vaoComponentsvaoNormvaoDiv ContextDataGPipeExceptionWindow getWinName WindowStatewindowContextData RenderStateperWindowRenderStaterenderWriteTexturesrenderLastUsedWinRenderunRenderContextTContextHandlerContextHandlerParameters ContextWindowWindowParameterscontextHandlerCreatecontextHandlerDelete createContextcontextDoAsync contextSwapcontextFrameBufferSize contextDeleterenderregisterRenderWriteTexture runContextT newWindow deleteWindowasSyncliftNonWinContextIOliftNonWinContextAsyncIOaddContextFinalizergetLastRenderWinswapWindowBuffersgetFrameBufferSizewithContextWindowaddVAOBufferFinalizeraddFBOTextureFinalizergetVAOsetVAOgetFBOsetFBO $fEqWindow$fExceptionGPipeException$fMonadFailContextT$fMonadTransContextT$fFunctorContextT$fApplicativeContextT$fMonadContextT$fMonadIOContextT$fMonadExceptionContextT$fMonadAsyncExceptionContextT $fMonadRender$fApplicativeRender$fFunctorRender $fEqFBOKeys $fOrdFBOKeys $fEqFBOKey $fOrdFBOKey $fEqVAOKey $fOrdVAOKey$fShowGPipeException RenderIOStateuniformNameToRenderIOsamplerNameToRenderIOrasterizationNameToRenderIOtransformFeedbackToRenderIOinputArrayToRenderIOBindingDrawcall drawcallFbofeedbackBuffer primitiveNamerasterizationName vertexSourceoptionalGeometrySourceoptionalFragmentSource usedInputs usedVUniforms usedVSamplers usedGUniforms usedGSamplers usedFUniforms usedFSamplersprimStrUBufferSizeWinId mapDrawcallnewRenderIOStatemapRenderIOStatecompileDrawcallssafeGenerateDrawcalls innerCompilecreateRenderercreateFeedbackRenderercompileOpenGlShader linkProgramcreateUniformBufferaddPrimitiveStreamUniformbind orderedUnion"oldAllocateWhichGiveStrangeResultsallocateConsecutiveIndexes getFboError whenJust' BufferColorBPacked NormalizedUniformB4unB4B3unB3B2unB2BbNamebOffsetbStride bSkipElems bInstanceDivToBufferUniformAlignmentBInput bInSkipElemsbInInstanceDivBufferStartPosBufferbufNamebufElementSize bufferLength bufBElementbufTransformFeedback BufferFormat HostFormattoBuffer getGlType peekPixelgetGlPaddedFormatbufSizetoB22toB3toB21toB12toB11 newBufferbufferWriteInternal writeBuffer copyBuffergetUniformAlignment makeBuffer$fArrowToBuffer$fCategoryTYPEToBuffer$fBufferFormatPlucker$fBufferFormatPoint$fBufferFormatQuaternion$fBufferFormat(,,,,,,)$fBufferFormat(,,,,,)$fBufferFormat(,,,,)$fBufferFormat(,,,)$fBufferFormat(,,)$fBufferFormat(,)$fBufferFormat()$fBufferFormatV4$fBufferFormatV3$fBufferFormatV2$fBufferFormatV1$fBufferFormatV0 $fEqBuffer$fBufferFormatB$fBufferFormatB0$fBufferFormatB1$fBufferFormatB2$fBufferFormatB20$fBufferFormatB21$fBufferFormatB22$fBufferFormatB23$fBufferFormatB3$fBufferFormatB30$fBufferFormatB31$fBufferFormatB32$fBufferFormatB33$fBufferFormatB34$fBufferFormatB35$fBufferFormatB4$fBufferFormatB40$fBufferFormatB41$fBufferFormatB42$fBufferFormatB43$fBufferFormatB44$fBufferFormatB45$fBufferFormatUniform$fBufferFormatNormalized$fBufferFormatBPacked$fBufferFormatBPacked0$fEqAlignmentModelookAt rotMatrixX rotMatrixY rotMatrixZ $fIfBPoint $fIfBPlucker$fIfBQuaternion$fIfBV4$fIfBV3$fIfBV2$fIfBV1$fIfBV0 $fEqBPoint $fEqBPlucker$fEqBQuaternion$fEqBV4$fEqBV3$fEqBV2$fEqBV1$fEqBV0CompiledShaderShaderShaderM ShaderState getNewNameaskUniformAlignmentmodifyRenderIO tellDrawcall mapShader maybeShader chooseShader silenceShaderguard' compileShader$fMonadPlusShader $fMonadShader$fAlternativeShader$fApplicativeShader$fFunctorShader$fMonadPlusShaderM$fMonadShaderM$fAlternativeShaderM$fApplicativeShaderM$fFunctorShaderMPrimitiveArraygetPrimitiveArrayPrimitiveArrayIntPrimitiveArraySimplePrimitiveArrayIndexedPrimitiveArrayInstancedPrimitiveArrayIndexedInstanced BaseVertex InstanceCountPrimitiveTopologyGeometry toGLtopologytoPrimitiveSizetoGeometryShaderOutputTopology toLayoutIn toLayoutOutTrianglesWithAdjacencyTriangleListAdjacencyTriangleStripAdjacency Triangles TriangleList TriangleStripLinesWithAdjacencyLineListAdjacencyLineStripAdjacencyLinesLineLoop LineStripLineListPoints PointList IndexArrayiArrNameindexArrayLengthoffsetrestart indexType IndexFormatCombine Instances VertexArrayvertexArrayLengthvertexArraySkip bArrBFuncnewVertexArray zipVertices takeVertices dropVertices replicateEach newIndexArray takeIndices dropIndicestoPrimitiveArraytoPrimitiveArrayIndexedtoPrimitiveArrayInstanced toPrimitiveArrayIndexedInstanced$fFunctorVertexArray)$fPrimitiveTopologyTrianglesWithAdjacency$fPrimitiveTopologyTriangles%$fPrimitiveTopologyLinesWithAdjacency$fPrimitiveTopologyLines$fPrimitiveTopologyPoints$fFunctorPrimitiveArray$fMonoidPrimitiveArray$fSemigroupPrimitiveArrayImageReferenceValue ColorSample SampleOffset3 SampleOffset2 SampleOffset1 SampleProj SampleLod3' SampleLod2' SampleLod3 SampleLod2 SampleLod1 SampleLod' SampleAuto' SampleBias' SampleGrad' SampleLod SampleAuto SampleBias SampleGrad SamplerCube Sampler3DSampler2DArray Sampler2DSampler1DArray Sampler1DShadowComparisonFunctionNeverLessEqualLequalGreaterNotequalGequalAlways EdgeMode3 EdgeMode2 SamplerFilterSamplerNearest LodFilter MagFilter MinFilter Anisotropy BorderColorEdgeModeRepeatMirror ClampToEdge ClampToBorderFilterNearestLinear StartPos3 StartPos2 StartPos1CubeSideCubePosXCubeNegXCubePosYCubeNegYCubePosZCubeNegZLevelTexNameSize3Size2Size1 MaxLevels TextureCube Texture3DTexture2DArray Texture2DRenderBuffer2DTexture1DArray Texture1D newTexture1DnewTexture1DArray newTexture2DnewTexture2DArray newTexture3DnewTextureCube getGlValuesetDefaultTexParamstexture1DLevelstexture1DArrayLevelstexture2DLevelstexture2DArrayLevelstexture3DLevelstextureCubeLevelstexture1DSizestexture1DArraySizestexture2DSizestexture2DArraySizestexture3DSizestextureCubeSizes calcLevelSize calcMaxLevelsmakeTexmakeRenderBuffuseTex useTexSyncgetGlColorFormatwriteTexture1DwriteTexture1DArraywriteTexture2DwriteTexture2DArraywriteTexture3DwriteTextureCubewriteTexture1DFromBufferwriteTexture1DArrayFromBufferwriteTexture2DFromBufferwriteTexture2DArrayFromBufferwriteTexture3DFromBufferwriteTextureCubeFromBuffer readTexture1DreadTexture1DArray readTexture2DreadTexture2DArray readTexture3DreadTextureCubereadTexture1DToBufferreadTexture1DArrayToBufferreadTexture2DToBufferreadTexture2DArrayToBufferreadTexture3DToBufferreadTextureCubeToBuffersetGlPixelStoreRangegenMipsgenerateTexture1DMipmapgenerateTexture1DArrayMipmapgenerateTexture2DMipmapgenerateTexture2DArrayMipmapgenerateTexture3DMipmapgenerateTextureCubeMipmap getGlCompFunc newSampler1DnewSampler1DArray newSampler2DnewSampler2DArray newSampler3DnewSamplerCubenewSampler1DShadownewSampler1DArrayShadownewSampler2DShadownewSampler2DArrayShadownewSamplerCubeShadowsetNoShadowMode setShadowFunc setEdgeModesetSamplerFiltersetSamplerFilter' doForSamplerfromLod'sample1D sample1DArraysample2D sample2DArraysample3D sampleCubesample1DShadowsample1DArrayShadowsample2DShadowsample2DArrayShadowsampleCubeShadowt1t3t2t3t3t4 texelFetch1DtexelFetch1DArray texelFetch2DtexelFetch2DArray texelFetch3D sampler1DSizesampler1DArraySize sampler2DSizesampler2DArraySize sampler3DSizesamplerCubeSizeaddShadowPrefixgetTextureSizesample sampleShadowfetchv1toFv2toFv3toFv4toFiv1toFiv2toFiv3toFciv1toFciv2toFciv3toFpv1toFpv2toFpv3toF sampleFunc fetchFuncoffParamoffName imageEqualsgetImageBindinggetImageFBOKey imageSizeregisterRenderWriteTextureNamegetTexture1DImagegetTexture1DArrayImagegetTexture2DImagegetTexture2DArrayImagegetTexture3DImagegetTextureCubeImagegetLayeredTextureImage getGlCubeSide $fEqImage$fEqComparisonFunction$fOrdComparisonFunction$fShowComparisonFunction $fEqEdgeMode$fEnumEdgeMode $fEqFilter $fEnumFilter $fEqCubeSide$fEnumCubeSide$fBoundedCubeSide ToUniform OffsetToSType UniformInput UniformFormat toUniform getUniform buildUDecl makeUniform$fUniformInputPlucker$fUniformInputQuaternion$fUniformInput(,,,,,,)$fUniformInput(,,,,,)$fUniformInput(,,,,)$fUniformInput(,,,)$fUniformInput(,,)$fUniformInput(,)$fUniformInput()$fUniformInputV4$fUniformInputV3$fUniformInputV2$fUniformInputV1$fUniformInputV0$fUniformInputB4$fUniformInputB40$fUniformInputB41$fUniformInputB3$fUniformInputB30$fUniformInputB31$fUniformInputB2$fUniformInputB20$fUniformInputB21$fUniformInputB$fUniformInputB0$fUniformInputB1$fCategoryTYPEToUniform$fArrowToUniform PointSize InputIndices inputVertexIDinputInstanceIDToVertex UniOffset VertexInput VertexFormattoVertexPrimitiveStreamPrimitiveStreamDataUSize PrimitiveNametoPrimitiveStreamtoPrimitiveStream'withInputIndices withPointSizeappend makeVertexFmakeBindVertexFxmakeBindVertexFnormmakeBindVertexF makeVertexImakeBindVertexInoWritertoUniformVertexunBnorm$fArrowToVertex$fCategoryTYPEToVertex$fVertexInputPlucker$fVertexInputPoint$fVertexInputQuaternion$fVertexInputV4$fVertexInputV3$fVertexInputV2$fVertexInputV1$fVertexInputV0$fVertexInput(,,,,,,)$fVertexInput(,,,,,)$fVertexInput(,,,,)$fVertexInput(,,,)$fVertexInput(,,)$fVertexInput(,)$fVertexInput()$fVertexInputB4$fVertexInputB40$fVertexInputB41$fVertexInputB42$fVertexInputB43$fVertexInputB44$fVertexInputNormalized$fVertexInputNormalized0$fVertexInputNormalized1$fVertexInputNormalized2$fVertexInputNormalized3$fVertexInputNormalized4$fVertexInputB45$fVertexInputB3$fVertexInputB30$fVertexInputB31$fVertexInputB32$fVertexInputB33$fVertexInputB34$fVertexInputNormalized5$fVertexInputNormalized6$fVertexInputNormalized7$fVertexInputNormalized8$fVertexInputNormalized9$fVertexInputNormalized10$fVertexInputB35$fVertexInputB2$fVertexInputB20$fVertexInputB21$fVertexInputB22$fVertexInputNormalized11$fVertexInputNormalized12$fVertexInputNormalized13$fVertexInputNormalized14$fVertexInputB23$fVertexInputB$fVertexInputB0$fVertexInputNormalized15$fVertexInputNormalized16$fVertexInputB1$fVertexInputWord32$fVertexInputInt32$fVertexInputFloat$fFunctorPrimitiveStream$fSemigroupPrimitiveStream$fMonoidPrimitiveStreamNoPerspectiveVFloat NoPerspective FlatVFloatFlatRasterizedInforasterizedFragCoordrasterizedFrontFacingrasterizedPointCoord DepthRangeminDepthmaxDepthViewPortviewPortLowerLeft viewPortSize PolygonMode PolygonFill PolygonLine PolygonPointSideFrontBack FrontAndBack FragmentInputFragmentFormat toFragment ToFragmentFragmentStreamFragmentStreamDataRasterizationNameExprPosVPos rasterizefilterFragmentswithRasterizedInfo makeFragmentunFlatunNPersp$fFunctorFragmentStream$fFragmentInputPlucker$fFragmentInputPoint$fFragmentInputQuaternion$fFragmentInput(,,,,,,)$fFragmentInput(,,,,,)$fFragmentInput(,,,,)$fFragmentInput(,,,)$fFragmentInput(,,)$fFragmentInput(,)$fFragmentInputV4$fFragmentInputV3$fFragmentInputV2$fFragmentInputV1$fFragmentInputV0$fFragmentInputS$fFragmentInputS0$fFragmentInputS1$fFragmentInputS2$fFragmentInput()$fFragmentInputFlatVFloat"$fFragmentInputNoPerspectiveVFloat$fCategoryTYPEToFragment$fArrowToFragment$fSemigroupFragmentStream$fMonoidFragmentStreamFragmentCreatorcreateFragmentAnotherFragmentInput toFragment2ToAnotherFragmentFragmentInputFromGeometrytoFragmentFromGeometryToFragmentFromGeometryGeometryExplosiveexploseGeometrydeclareGeometryenumerateVaryingsAnotherVertexInputtoAnotherVertexToAnotherVertex GeometryInput toGeometry ToGeometryGeometryStreamGeometryStreamData LayoutNameGeometrizationNamemakeAnotherVertex geometrizenotMeantToBeReadgenerativePointsgenerativeLineStripgenerativeTriangleStrip emitVertexemitVertexPositionemitVertexLayeremitVertexPositionAndLayer endPrimitivedefaultExploseGeometrydefaultDeclareGeometrydefaultEnumerateVaryingsgenerateAndRasterizemakeAnotherFragment$fFunctorGeometryStream$fArrowToAnotherVertex$fCategoryTYPEToAnotherVertex$fAnotherVertexInputPlucker$fAnotherVertexInputQuaternion$fAnotherVertexInput(,,,,,,)$fAnotherVertexInput(,,,,,)$fAnotherVertexInput(,,,,)$fAnotherVertexInput(,,,)$fAnotherVertexInput(,,)$fAnotherVertexInput(,)$fAnotherVertexInputV4$fAnotherVertexInputV3$fAnotherVertexInputV2$fAnotherVertexInputV1$fAnotherVertexInputV0$fAnotherVertexInputS$fAnotherVertexInputS0$fAnotherVertexInputS1'$fAnotherVertexInputNoPerspectiveVFloat$fAnotherVertexInputFlatVFloat$fAnotherVertexInputS2$fAnotherVertexInput()&$fGeometryInputTrianglesWithAdjacencya$fGeometryInputTrianglesa"$fGeometryInputLinesWithAdjacencya$fGeometryInputLinesa$fGeometryInputPointsa$fGeometryExplosive(,,,,,,)$fGeometryExplosive(,,,,,)$fGeometryExplosive(,,,,)$fGeometryExplosive(,,,)$fGeometryExplosive(,,)$fGeometryExplosive(,)$fGeometryExplosiveV4$fGeometryExplosiveV3$fGeometryExplosiveV2$fGeometryExplosiveV1$fGeometryExplosiveV0$fGeometryExplosiveS$fGeometryExplosiveS0$fGeometryExplosiveS1&$fGeometryExplosiveNoPerspectiveVFloat$fGeometryExplosiveFlatVFloat$fGeometryExplosiveS2$fGeometryExplosive()$fAnotherFragmentInputPlucker$fAnotherFragmentInputPoint $fAnotherFragmentInputQuaternion$fAnotherFragmentInput(,,,,,,)$fAnotherFragmentInput(,,,,,)$fAnotherFragmentInput(,,,,)$fAnotherFragmentInput(,,,)$fAnotherFragmentInput(,,)$fAnotherFragmentInput(,)$fAnotherFragmentInputV4$fAnotherFragmentInputV3$fAnotherFragmentInputV2$fAnotherFragmentInputV1$fAnotherFragmentInputV0$fAnotherFragmentInputS$fAnotherFragmentInputS0$fAnotherFragmentInputS1)$fAnotherFragmentInputNoPerspectiveVFloat $fAnotherFragmentInputFlatVFloat$fAnotherFragmentInputS2$fAnotherFragmentInput()$fFragmentCreatorPlucker$fFragmentCreatorPoint$fFragmentCreatorQuaternion$fFragmentCreator(,,,,,,)$fFragmentCreator(,,,,,)$fFragmentCreator(,,,,)$fFragmentCreator(,,,)$fFragmentCreator(,,)$fFragmentCreator(,)$fFragmentCreatorV4$fFragmentCreatorV3$fFragmentCreatorV2$fFragmentCreatorV1$fFragmentCreatorV0$fFragmentCreatorS$fFragmentCreatorS0$fFragmentCreatorS1$$fFragmentCreatorNoPerspectiveVFloat$fFragmentCreatorFlatVFloat$fFragmentCreatorS2$fFragmentCreator()%$fFragmentInputFromGeometryTrianglesa$fCategoryTYPEToAnotherFragment$fArrowToAnotherFragment$$fCategoryTYPEToFragmentFromGeometry$fArrowToFragmentFromGeometry$fCategoryTYPEToGeometry$fArrowToGeometry$fSemigroupGeometryStream$fMonoidGeometryStream drawNothing tellDrawcalls makeDrawcall StencilOpOpZeroOpKeep OpReplaceOpIncr OpIncrWrapOpDecr OpDecrWrapOpInvertLogicOpClearAnd AndReverseCopy AndInvertedNoopXorOrNorEquivInvert OrReverse CopyInverted OrInvertedNandSetBlendingFactorZeroOneSrcColorOneMinusSrcColorDstColorOneMinusDstColorSrcAlphaOneMinusSrcAlphaDstAlphaOneMinusDstAlpha ConstantColorOneMinusConstantColor ConstantAlphaOneMinusConstantAlphaSrcAlphaSaturate BlendEquationFuncAdd FuncSubtractFuncReverseSubtractMinMaxBlendingFactorsblendFactorSrcblendFactorDstBlending NoBlending BlendRgbAlpha UseBlending DepthFunction DepthMask ColorMask FrontBackfrontbackDepthStencilOptiondsStencilOptions dsDepthOptionopWhenStencilPassButDepthFail StencilOption stencilTeststencilReferenceopWhenStencilFailopWhenStencilPassstencilReadBitMaskstencilWriteBitMaskStencilOptions DepthOptionContextColorOption FragDepth FragColor DrawColors runDrawColors drawColor makeFBOKeysdraw drawDepth drawStencildrawDepthStencildrawWindowColordrawWindowDepthdrawWindowColorDepthdrawWindowStencildrawWindowColorStencildrawWindowDepthStencildrawWindowColorDepthStencilsetColorsetDepthmake3setGlColorMasksetGlContextColorOptions setGlBlendsetGlDepthOptionssetGlStencilOptionssetGlDepthStencilOptionsusesConstantColorclearImageColorclearImageDepthclearImageStencilclearImageDepthStencilinWinclearWindowColorclearWindowDepthclearWindowStencilclearWindowDepthStencil maybeThrowglTruegetGlBlendEquationgetGlBlendFunc getGlLogicOpgetGlStencilOp$fFunctorDrawColors$fApplicativeDrawColors$fMonadDrawColorsscopedM SNMapReaderTrunSNMapReaderTmemoizeMghc-prim GHC.TypesFloatDouble6Boolean-0.2.4-a4ba0d4af198c0677cb1add184fe6b8ba8234d60 Data.BooleanifBtrueIObaseGHC.WordWord8Word16IntWord GHC.MaybeMaybeJust Data.EitherEitherLeftRightGHC.BaseFunctorLineTriangleWithAdjacencyTriangleLineWithAdjacencyPointMonoidfmapGHC.Err undefinedFalseTruesort2BmaxBminBcaseBguardedBcropcondbooleanBoolean||*&&*notBfalse BooleanOfIfBEqB==*/=*OrdB>=*>*<*<=*