!4      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ 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 t u v w x y z { | } ~                                                                     !"#$%&'()*+,-./0123 NoneEMSX4GPipeWRun a subcomputation in a scope, where nothing memoized inside will be remembered after56789:4None&'=>?@AGHSVXG,GPipe]Provides a common way to convert numeric types to integer and floating point representations.GPipe#Convert to a floating point number.GPipe=Convert to an integral number, using truncation if necessary.GPipeFConvert to an unsigned integral number, using truncation if necessary.GPipe5This class provides various order comparing functions GPipeThis 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.GPipeConstraint 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.GPipe5A base type that this type can convert into. Use the % function on an existing instance of ! to define this in your instance.GPipebConvert this type to the shader base type. Make sure this is as lazy as possible (e.g. use tilde (~) on each pattern match).GPipe4Convert back from the shader base type to this type.GPipeAn opaque type&GPipe'Phantom type used as first argument in ( & a7 that denotes that the shader value is a fragment value'GPipe'Phantom type used as first argument in ( ' a5 that denotes that the shader value is a vertex value)GPipeWorks 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 aJ is a compound type (e.g. a tuple or a vector). For simple types such as  S x Float, ifThenElse' == ifB.*GPipeifThenElse 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 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 while f g x will iteratively transform x with g as long as f generates >.-GPipeEThe derivative in x using local differencing of the rasterized value..GPipeEThe derivative in y using local differencing of the rasterized value./GPipe_The sum of the absolute derivative in x and y using local differencing of the rasterized value.   ?@ABCDE !"#$%&'(FGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwx)*+y,z{|}~-./    NoneK[0    !"#$%&'()*+,-./0('&%$#"!     -./,+*)None &'=>?@AGHVMq01:98765432; <=>?A@BC~}|{zyxwvutsrqponlkjihgfedcba`_^]\[ZYXWVUTSRQPONMLKJIHGFEDmNone &'2=>?HMSVXGPipeThe reason we need this is that we need to bind a finalizer to a buffer or texture that removes all references VAOs or FBOs from all known ContextData at a future point, where more Contexts may have been created.GPipeThis 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!A monad in which shaders are run.GPipeXThe 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.os`An 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.GPipeYClass implementing a window handler that can create openGL contexts, such as GLFW or GLUTGPipecImplementation specific context handler parameters, eg error handling and event processing policiesGPipe#Implementation specific window typeGPipePImplementation specific window parameters, eg initial size and border decorationGPipe5Create a context handler. Called from the main threadGPipe}Delete the context handler. All contexts created from this handler will be deleted using contextDelete prior to calling this.GPipeTCreate 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`Run 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.GPipeSwap 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.GPipeGet 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 )GPipewDelete a context and close any associated window. Only ever called from the mainthread (i.e. the thread that called u). Only ever called once per window, and will always be called for each window before the context is deleted with .GPipeRun a G monad, that may have the effect of windows or textures being drawn to. May throw a e if a combination of draw images (FBO) used by this render call is unsupported by the graphics driverGPipeRun a Y 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.GPipeCreates a windowGPipeBDeletes a window. Any rendering to this window will become a noop.GPipeRun 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.GPipeReturn 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.GPipeUse the context window handle, which type is specific to the window system used. This handle shouldn't be returned from this function!GPipeRemoves a VAO entry from all SharedContextDatas when one of the buffers are deleted. This will in turn make the VAO finalizer to be run."GPipeRemoves a FBO entry from all SharedContextDatas when one of the textures are deleted. This will in turn make the FBO finalizer to be run.A#$%&'()*+,-./0123456789:;<=>?@ABCDEF!"GHIJNoneQgKGPipeMay throw a GPipeExceptionLMNOPQRSTUVWXYZ[\]^_`abcKdefgNone =>?HVXgGPipeThis 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.GPipeThis 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 h or i.GPipeThis 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. j or k).GPipe,Any 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.GPipe5An atomic buffer value that represents a vector of 4 a{s 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.GPipe5An atomic buffer value that represents a vector of 3 as on the host.GPipe5An atomic buffer value that represents a vector of 2 as on the host.GPipe=The atomic buffer value that represents a host value of type a.GPipeThe arrow type for .GPipeA  Buffer os b lives in the object space os and contains elements of type b.GPipe,Retrieve the number of elements in a buffer.GPipe<The class that constraints which types can live in a buffer.GPipeYThe type a value of this format has when it lives on the host (i.e. normal Haskell world)GPipedAn arrow action that turns a value from it's host representation to it's buffer 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 use proc ~pattern -> do ...GPipe Split up a  a into two  as.GPipe Discard the last component of a  a to get a  a.GPipe Split up a  a into a  a and a B1 a.GPipe Split up a  a into a B1 a and a  a.GPipe Split up a  a into two B1 as.GPipe4Create a buffer with a specified number of elements.GPipe=Write a buffer from the host (i.e. the normal Haskell world).GPipe<Copies values from one buffer to another (of the same type).7copyBuffer fromBuffer fromStart toBuffer toStart length will copy length elements from position  fromStart in  fromBuffer to position toStart in toBuffer.5lmnopqrstuvwxyz{|}~NoneHVNoneNoneHVm0123456789:;<=>?@ABCmDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklnopqrstuvwxyz{|}~mCmDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklnopqrstuvwxyz{|}~B?@A>=<123456789:;0Safe>HVȜNone&'=>?@AEHMSVXGPipeMA compiled shader is just a function that takes an environment and returns a  actionGPipe[The 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.GPipeoMap the environment to a different environment and run a Shader in that sub environment, returning it's result.GPipe1Conditionally run the effects of a shader when a  value is  something.GPipeLike guard, but dependent on the Shadersk 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 F diverge. You can break that divergence by combining it with a normal guard and a maximum loop count.GPipeSelect one of two  actions based on whether an  value is  or .GPipeDiscard all effects of a G action (i.e., dont draw anything) and just return the resulting value.GPipeCompiles a shader into a c. This action will usually take a second or more, so put it during a loading sequence or something. May throw a  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 &'=?GHVXjGPipeAn array of primitivesGPipexAn 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.GPipeNumer of indices in an .GPipe"A phantom type to indicate that a $ may only be used for instances (in  and ).GPipegA 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 tD indicates whether the vertex array may be used as instances or not.GPipe%Retrieve the number of elements in a .GPipe Create a  from a L. The vertex array will have the same number of elements as the buffer, use  and  to make it smaller.GPipeZip two Hs using the function given as first argument. If either of the argument s are restriced to B only, then so will the resulting array be, as depicted by the  type family.GPipetakeVertices n a. creates a shorter vertex array by taking the n first elements of the array a.GPipedropVertices 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 .GPipereplicateEach n al 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...}i. This is particulary useful before zipping the array with another that has a different replication rate.GPipe Create an  from a 4 of unsigned integers (as constrained by the closed b type family instances). The index array will have the same number of elements as the buffer, use  and  to make it smaller. The Maybe aA argument is used to optionally denote a primitive restart index.GPipetakeIndices n a- creates a shorter index array by taking the n first indices of the array a.GPipedropIndices n a/ creates a shorter index array by dropping the n first indices of the array a.1None&'=>?@AGHVX0GPipe_A 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.The type of a color sample made by a texture tGPipepFor some reason, OpenGl doesnt allow explicit lod to be specified for some sampler types, hence this extra GADT.GPipeA 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.GPipeUsed instead of CJ for shadow samplers. These samplers have specialized sampler values, see  and friends.GPipe!A GADT for sample filters, where % cannot be used for integer textures.GPipe9Compare two images that doesn't necessarily has same typeGPipeRetrieve the 2D size an image      !"#'&%$()*+,-.43210/56789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None&'=>?@AHMVXGPipeThe arrow type for .GPipeeThis class constraints which buffer types can be loaded as uniforms, and what type those values have.GPipe^The type the buffer value will be turned into once it becomes a vertex or fragment value (the x parameter is either ' or &).GPiperAn 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 ....GPipeLoad a uniform value from a  into a r. The argument function is used to retrieve the buffer and the index into this buffer from the shader environment. None =>?HMVXg3GPipeThe arrow type for .GPipelThis class constraints which buffer types can be turned into vertex values, and what type those values have.GPipeMThe type the buffer value will be turned into once it becomes a vertex value.GPipefAn 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 ....GPipeA  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 T 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 <s instead, as this will create more optimized draw calls.GPipeVCreate a primitive stream from a primitive array provided from the shader environment.GPipeLike J, but where the vertex and instance IDs are provided as arguments as well.GPipeLike , but where each point's size is provided as arguments as well, and a new point size is set for each point in addition to the new vertex value.When a  of 8 is created, all points will have the default size of 1.None =>?HMVXR GPipegA float value that doesn't get divided by the interpolated position's w-component during interpolation.GPipeA float value that is not interpolated (like integers), and all fragments will instead get the value of the primitive's last vertexGPipesThe 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.GPipeThe 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.GPipeODefines which side to rasterize. Non triangle primitives only has a front side.GPipenThis class constraints which vertex types can be turned into fragment values, and what type those values have.GPipeOThe type the vertex value will be turned into once it becomes a fragment value.GPipehAn 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 ....GPipeThe arrow type for .GPipeA  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).GPipe9Rasterize 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.GPipe\Filter out fragments from the stream where the predicate in the first argument evaluates to >", and discard all other fragments.GPipeLike b, but where various auto generated information from the rasterization is provided for each vertex.'NoneMPX"GPipeJDenotes the operation that will be performed on the target's stencil valueGPipemA bitwise logical operation that will be used to combine colors that has an integral internal representation.GPipe~A factor that the source (fragment) or the destination (target) will be multiplied with before combined with the other in the .GPipeThe equation used to combine the source (fragment) and the destination (target) after they have been multiplied with their respective s.GPipeVA set of blending factors used for the source (fragment) and the destination (target).GPipePDenotes how each fragment's color value should be blended with the target value.GPipe:The fragment's color will simply replace the target value.GPipeThe 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 G needs it. This kind of blending will only be made on colors with a ; representation (e.g. _ or f , but not j7), integer colors will simply replace the target value.GPipeA 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. _ or j , but not f; note the difference with  BlendRgbAlpha restriction). For targets with an internal floating point representation, the fragment value will simply replace the target value.GPipe1Indicates whether this color draw should use the . setting given to the draw action. If this is E, the fragment's color value will simply replace the target value.GPipeYThe function used to compare the fragment's depth and the depth buffers depth with. E.g. G means "where fragment's depth is less than the buffers current depth".GPipe 8 if the depth component should be written to the target.GPipe ? for each color component that should be written to the target.GPipe6A monad in which individual color images can be drawn. GPipe8Draw color values into a color renderable texture image.!GPipeDraw all fragments in a D using the provided function that passes each fragment value into a = monad. The first argument is a function that retrieves a A setting from the shader environment, which will be used for all   actions in the  monad where  is  o. (OpenGl 3.3 unfortunately doesn't support having different blending settings for different color targets.)"GPipeLike !8, but performs a depth test on each fragment first. The B monad is then only run for fragments where the depth test passes.#GPipeLike !:, but performs a stencil test on each fragment first. The D monad is then only run for fragments where the stencil test passes.$GPipeLike ![, but performs a stencil test and a depth test (in that order) on each fragment first. The N monad is then only run for fragments where the stencil and depth test passes.%GPipeDraw color values from a  into the window.&GPipe.Perform a depth test for each fragment from a U in the window. This doesn't draw any color values and only affects the depth buffer.'GPipe.Perform a depth test for each fragment from a Q and write a color value from each fragment that passes the test into the window.(GPipe0Perform a stencil test for each fragment from a W in the window. This doesn't draw any color values and only affects the stencil buffer.)GPipe0Perform a stencil test for each fragment from a Q and write a color value from each fragment that passes the test into the window.*GPipeOPerform 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.+GPipeOPerform a stencil test and depth test (in that order) for each fragment from a R and write a color value from each fragment that passes the tests into the window.,GPipe.Fill a color image with a constant color value-GPipeCFill a depth image with a constant depth value (in the range [0,1]).GPipe0Fill a depth image with a constant stencil value/GPipeqFill a combined depth stencil image with a constant depth value (in the range [0,1]) and a constant stencil value0GPipe9Fill the window's back buffer with a constant color value1GPipeTFill the window's back depth buffer with a constant depth value (in the range [0,1])2GPipeCFill the window's back stencil buffer with a constant stencil value3GPipe~Fill the window's back depth and stencil buffers with a constant depth value (in the range [0,1]) and a constant stencil value         !"#$%&'()*+ ,-./0123Nones      !"#$%&'()*+,-./0123s%&'()*+!"#$ 0123,-./      NoneSafeNone$$ NoneE   NoneX      !"#$%&'(*)pqrstuvwxyz{|}~X     pqrstuvwxyz(*)#$%&'"! |}~{None None_E+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoE?>=<;:./01234@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]jklmno^_`abcdefghi95876-,+NoneNone+' !"#$%&'(>)*+,-.=/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~         !"#$%&'()*+,-./0123456789:;<=>?@ABCmDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklnopqrstuvwxyz{|}~      !"#$%&'(*)+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./01233456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&&''()*+,-./0123456789:;<=> ? @ A B C D EFGHFGIJKLJKMNOPQRSTEUVWWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,FG-./0012344567889:;<=>?@@ABBCDEFGHIJKLMNOPQRSSTUVWXYYZ[\]^_`abcdefghijklmnlmoFGpFGqrstuvwxyz{{|}~llllll !"#$%&QRSTUVlllFGFG*JK JK JK JK JK JKJKJKJKJKJKJKJKJKJKJKJKJKJKJKJKJKJK !" !# !# !$ %& %' %( %) %* %+ %, %- %. %/ 01 02 03 04 05 06 07 08 09 :; :< := :> :? :@ :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 ef eg eh ij ik il im in io ip iq ir is it iu iv iw ix iy iy iz i{ i| i} i~ i i                                                                                                                              "GPipe-2.2.5-67uzSsvDqyu4ervG2ZOzXlGraphics.GPipe.ExprGraphics.GPipe.FormatGraphics.GPipe.ContextGraphics.GPipe.ShaderGraphics.GPipe.BufferGraphics.GPipe.UniformGraphics.GPipe.PrimitiveArrayGraphics.GPipe.FrameBufferGraphics.GPipe.SamplerGraphics.GPipe.TextureGraphics.GPipe.PrimitiveStreamGraphics.GPipe.FragmentStream Data.SNMapGraphics.GPipe.Internal.ExprGraphics.GPipe.Internal.FormatGraphics.GPipe.Internal.Context Graphics.GPipe.Internal.CompilerGraphics.GPipe.Internal.BufferGraphics.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.FrameBufferGraphics.GPipe.OrphansGraphics.GPipeConvert ConvertFloat ConvertInt ConvertWordtoFloattoInttoWord FloatingOrdclampsaturatestep smoothstepReal'rsqrtexp2log2floor'ceiling'fract'mod''mixatan2' Integral'div'mod' ShaderTypeShaderBaseTypetoBasefromBase ShaderBaseFBoolFWordFIntFFloatVBoolVWordVIntVFloatFVS ifThenElse' ifThenElseifThenwhiledFdxdFdyfwidth WindowBits WindowFormatWindowFormatColorWindowFormatColorDepthWindowFormatColorStencil%WindowFormatColorDepthStencilSeparate%WindowFormatColorDepthStencilCombinedWindowFormatDepthWindowFormatStencil WindowFormatDepthStencilSeparate WindowFormatDepthStencilCombinedContextColorFormatStencilRenderableDepthRenderableColorRenderableColorSampleableColor ColorElement TextureFormatFormatR8R8SR16R16SR16FR32FR8IR16IR32IR8UIR16UIR32UIRG8RG8SRG16RG16SRG16FRG32FRG8IRG16IRG32IRG8UIRG16UIRG32UIR3G3B2RGB4RGB5RGB8RGB8SRGB10RGB12RGB16RGB16SRGB16FRGB32F R11FG11FB10FRGB9E5SRGB8RGB8IRGB16IRGB32IRGBWordRGB8UIRGB16UIRGB32UIRGBA2RGBA4RGB5A1RGBA8RGBA8SRGB10A2RGBA12RGBA16RGBA16SRGBA16FRGBA32FSRGB8A8RGBA8IRGBA16IRGBA32IRGBA8UIRGBA16UIRGBA32UIDepth16Depth24Depth32Depth32FStencil1Stencil4Stencil8 Stencil16Depth24Stencil8Depth32FStencil8 DepthStencilStencilDepthRGBAWordRGBAInt RGBAFloatRGBIntRGBFloatRGWordRGIntRGFloatRWordRIntRFloat windowBitsGPipeExceptionWindowRenderContextTContextHandlerContextHandlerParameters ContextWindowWindowParameterscontextHandlerCreatecontextHandlerDelete createContextcontextDoAsync contextSwapcontextFrameBufferSize contextDeleterender runContextT newWindow deleteWindowswapWindowBuffersgetFrameBufferSizewithContextWindow BufferColorBPacked NormalizedUniformB4B3B2BToBufferBufferStartPosBuffer bufferLength BufferFormat HostFormattoBuffertoB22toB3toB21toB12toB11 newBuffer writeBuffer copyBufferCompiledShaderShader mapShader maybeShaderguard' chooseShader silenceShader compileShaderPrimitiveArrayPrimitiveTopology TriangleList TriangleStrip TriangleFanLineList LineStripLineLoop PointListPointsLines Triangles IndexArrayindexArrayLength IndexFormatCombine Instances VertexArrayvertexArrayLengthnewVertexArray zipVertices takeVertices dropVertices replicateEach newIndexArray takeIndices dropIndicestoPrimitiveArraytoPrimitiveArrayIndexedtoPrimitiveArrayInstanced toPrimitiveArrayIndexedInstancedImageReferenceValue 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 StartPos1CubeSideCubePosXCubeNegXCubePosYCubeNegYCubePosZCubeNegZLevelSize3Size2Size1 MaxLevels TextureCube Texture3DTexture2DArray Texture2DTexture1DArray Texture1D newTexture1DnewTexture1DArray newTexture2DnewTexture2DArray newTexture3DnewTextureCubetexture1DLevelstexture1DArrayLevelstexture2DLevelstexture2DArrayLevelstexture3DLevelstextureCubeLevelstexture1DSizestexture1DArraySizestexture2DSizestexture2DArraySizestexture3DSizestextureCubeSizeswriteTexture1DwriteTexture1DArraywriteTexture2DwriteTexture2DArraywriteTexture3DwriteTextureCubewriteTexture1DFromBufferwriteTexture1DArrayFromBufferwriteTexture2DFromBufferwriteTexture2DArrayFromBufferwriteTexture3DFromBufferwriteTextureCubeFromBuffer readTexture1DreadTexture1DArray readTexture2DreadTexture2DArray readTexture3DreadTextureCubereadTexture1DToBufferreadTexture1DArrayToBufferreadTexture2DToBufferreadTexture2DArrayToBufferreadTexture3DToBufferreadTextureCubeToBuffergenerateTexture1DMipmapgenerateTexture1DArrayMipmapgenerateTexture2DMipmapgenerateTexture2DArrayMipmapgenerateTexture3DMipmapgenerateTextureCubeMipmap newSampler1DnewSampler1DArray newSampler2DnewSampler2DArray newSampler3DnewSamplerCubenewSampler1DShadownewSampler1DArrayShadownewSampler2DShadownewSampler2DArrayShadownewSamplerCubeShadowfromLod'sample1D sample1DArraysample2D sample2DArraysample3D sampleCubesample1DShadowsample1DArrayShadowsample2DShadowsample2DArrayShadowsampleCubeShadow texelFetch1DtexelFetch1DArray texelFetch2DtexelFetch2DArray texelFetch3D sampler1DSizesampler1DArraySize sampler2DSizesampler2DArraySize sampler3DSizesamplerCubeSize imageEquals imageSizegetTexture1DImagegetTexture1DArrayImagegetTexture2DImagegetTexture2DArrayImagegetTexture3DImagegetTextureCubeImage ToUniform UniformInput UniformFormat toUniform getUniform PointSize InputIndices inputVertexIDinputInstanceIDToVertex VertexInput VertexFormattoVertexPrimitiveStreamtoPrimitiveStreamwithInputIndices withPointSizeNoPerspectiveVFloat NoPerspective FlatVFloatFlatRasterizedInforasterizedFragCoordrasterizedFrontFacingrasterizedPointCoord DepthRangeminDepthmaxDepthViewPortviewPortLowerLeft viewPortSizeSideFrontBack FrontAndBack FragmentInputFragmentFormat toFragment ToFragmentFragmentStreamVPos rasterizefilterFragmentswithRasterizedInfo 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 drawColordraw drawDepth drawStencildrawDepthStencildrawWindowColordrawWindowDepthdrawWindowColorDepthdrawWindowStencildrawWindowColorStencildrawWindowDepthStencildrawWindowColorDepthStencilclearImageColorclearImageDepthclearImageStencilclearImageDepthStencilclearWindowColorclearWindowDepthclearWindowStencilclearWindowDepthStencilscopedM SNMapReaderTSNMapnewSNMapmemoizerunSNMapReaderTmemoizeMghc-prim GHC.TypesFloatDouble$Boolean-0.2.4-E63HERI2m4QLr7c9NoUMrA Data.BooleanifBtrueShaderBaseProdShaderBaseUnitShaderBaseBoolShaderBaseWord ShaderBaseIntShaderBaseFloatRValueunS GlobDeclM ExprStateshaderUsedInputshaderUsedSamplersshaderUsedUniformBlocksExprMSType STypeUVec STypeIVecSTypeVecSTypeMatSTypeDyn STypeUInt STypeBoolSTypeInt STypeFloat NextGlobal NextTempVar stypeName stypeSizerunExprMscalarSvec2Svec3Svec4SscalarS'vec2S'vec3S'vec4S'vec2S''vec3S''vec4S'' useVInput useFInput useUniform useSamplergetNexttellAssignmenttellAssignment'discard tellGlobalLn tellGlobalshaderbaseDeclareshaderbaseAssignshaderbaseReturnshaderbaseDeclareDefshaderbaseAssignDefshaderbaseReturnDeftellIf errShaderTypebinfun1fun2fun3fun4postoppreopbinffun1ffun2ffun3fpreopfpostopfbinifun1ipreopibinufun1upreopufromVfromVec4fromVec3fromVec2 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 alphaBitsblueBits greenBitsredBits clearColorisSrgb samplerPrefixsetBorderColor fromColortoColortypeStr4typeStr getGlFormatgetGlInternalFormat colorBits depthBits stencilBitsdepthStencilBitsSharedContextDatasIOaddVAOBufferFinalizeraddFBOTextureFinalizerFBOKeys fboColorsfboDepth fboStencilFBOKeyfboTnamefboTlayerOrNegIfRendBuff fboTlevelVAOKeyvaoBnamevaoCombBufferOffset vaoComponentsvaoNormvaoDiv ContextData getWinName WindowStatewindowContextData RenderStateperWindowRenderStaterenderWriteTexturesrenderLastUsedWinunRenderregisterRenderWriteTextureasSyncliftNonWinContextIOliftNonWinContextAsyncIOaddContextFinalizergetLastRenderWingetVAOsetVAOgetFBOsetFBOcompileAsserter RenderIOStateinputArrayToRenderIOsrasterizationNameToRenderIOsamplerNameToRenderIOuniformNameToRenderIOBindingDrawcallprimStrUBufferSize usedFSamplers usedFUniforms usedVSamplers usedVUniforms usedInputsfragmentSource vertexsSourcerasterizationName drawcallName drawcallFBOWinIdnewRenderIOStatemapRenderIOStatebind orderedUnionallocate getFBOerrorbaseGHC.WordWord8Word16IntWordunB4unB3unB2bNamebOffsetbStride bSkipElems bInstanceDivUniformAlignmentBInput bInSkipElemsbInInstanceDiv bufBElementbufElementSizebufName getGlType peekPixelgetGlPaddedFormatbufSizebufferWriteInternalgetUniformAlignment makeBuffer GHC.MaybeMaybeJust Data.EitherEitherLeftRightShaderM ShaderStategetNameaskUniformAlignmentmodifyRenderIO tellDrawcallGHC.BaseFunctorgetPrimitiveArrayPrimitiveArrayIntPrimitiveArrayIndexedInstancedPrimitiveArrayInstancedPrimitiveArrayIndexedPrimitiveArraySimple BaseVertex InstanceCount indexTyperestartiArrNameoffset bArrBFuncvertexArraySkip toGLtopologyTexNameRenderBuffer2D getGlValuesetDefaultTexParams calcLevelSize calcMaxLevelsmakeTexmakeRenderBuffuseTex useTexSyncgetGlColorFormatsetGlPixelStoreRangegenMips getGlCompFuncsetNoShadowMode setShadowFunc setEdgeModesetSamplerFiltersetSamplerFilter' doForSamplert1t3t2t3t3t4addShadowPrefixgetTextureSizesample sampleShadowfetchv1toFv2toFv3toFv4toFiv1toFiv2toFiv3toFciv1toFciv2toFciv3toFpv1toFpv2toFpv3toF sampleFunc fetchFuncoffParamoffNamegetImageBindinggetImageFBOKeyregisterRenderWriteTextureName getGlCubeSide OffsetToSType buildUDecl makeUniformMonoidfmap UniOffsetPrimitiveStreamDataUSize DrawCallName makeVertexFappendmakeBindVertexFxmakeBindVertexFnormmakeBindVertexF makeVertexImakeBindVertexInoWritertoUniformVertexunBnormFragmentStreamDataRasterizationNameExprPos makeFragmentunFlatunNPerspGHC.Err undefinedFalseTrue runDrawColors makeFBOKeys tellDrawcalls makeDrawcallsetColorsetDepthmake3setGlColorMasksetGlContextColorOptions setGlBlendsetGlDepthOptionssetGlStencilOptionssetGlDepthStencilOptionsusesConstantColorinWin maybeThrowglTruegetGlBlendEquationgetGlBlendFunc getGlLogicOpgetGlStencilOpsort2BmaxBminBcaseBguardedBcropcondbooleanBooleanfalsenotB&&*||* BooleanOfIfBEqB==*/=*OrdB<*<=*>*>=*$linear-1.20.9-3z2CKG8VnzuEuGOCJBsHWGLinear.Covector$*Covector runCovectorLinear.Algebra counitalRep comultRep unitalRepmultRepAlgebramultunital CoalgebracomultcounitalLinear.Projection inverseOrthoorthoinverseInfinitePerspectiveinfinitePerspectiveinverseFrustumfrustuminversePerspective perspectivelookAt Linear.Matrixinv44 transposeinv33inv22det44det33det22_m44_m43_m42_m34_m33_m32_m24_m23_m22 translationidentity m33_to_m44 m43_to_m44mkTransformationmkTransformationMatfromQuaternionadjoint!!/!!**!!*!!*!-!!+!!*!columnM22M23M24M32M33M34M42M43M44 Linear.TraceTracetracediagonalLinear.Quaternion axisAnglerotateslerpatanhqacoshqasinhqatanqacosqasinqpowabsiekejeiee Quaternion Complicated_e_i Hamiltonian_j_k_ijk 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_xwV4R4_w_xyzw Linear.V3triplecrossez_zyx_zxy_yzx_yxz_xzy_zy_zx_yz_xzV3R3_z_xyz Linear.V2crossZangleperpey_yxV2R2_y_xy Linear.V1exV1R1_x Linear.Metricproject normalizeMetricdot quadranceqddistancenormsignorm Linear.VectorouterunitscaledbasisForbasis^/^**^sumVnegatedEelAdditivezero^+^^-^lerpliftU2liftI2Linear.EpsilonEpsilonnearZeroLinear.Conjugate Conjugate conjugateTrivialConjugate Linear.Binary getLinear putLinear