/      !"#$%&'()*+,-./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 pqrstuvwxyz{|}~                                               !"#$%&'()*+,-. None:BHM /01234567/13456/01234567 Safe-Inferred3=K89:;<=>?@ABCDEFGHIJKLMNO89:;<=>?@ABCDEFGHIJKLMNONone !"2346<=K PQRS TUVWXYZ[\ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk]^_`albcdefghijklmnopqrstuvwxyz{|}~ PQRS TUVWXYZ[\ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijk]^_`alN  PQRS TUVWXYZ[\I\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! ]^_`abcdefghijk]^_`albcdefghijklmnopqrstuvwxyz{|}~None!"2346<=HKM m^Provides a common way to convert numeric types to integer and floating point representations. q$Convert to a floating point number. r>Convert to an integral number, using truncation if necessary. sGConvert to an unsigned integral number, using truncation if necessary. t7This class provides various order comparing functions yThis 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. 'Phantom type used as first argument in   aF that denotes that the shader value is a fragment value 'Phantom type used as first argument in   aD that denotes that the shader value is a vertex value FThe derivative in x using local differencing of the rasterized value. FThe derivative in y using local differencing of the rasterized value. `The sum of the absolute derivative in x and y using local differencing of the rasterized value. =mnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~mnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None !"+234BHMThis 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) "A monad in which shaders are run. YThe monad transformer that encapsulates a GPipe context (which wraps an OpenGl context). A value of type ContextT w os f m a2 is an action on a context with these parameters: wThe type of the window that is bound to this context. It is defined by the window manager package and is probably an opaque type. 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). fHThe format of the context's default frame buffer, always an instance of . 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. Like a  but creates a context that shares the object space of this handle's context. Called from same thread as created the initial context. kRun an OpenGL IO action in this context, returning a value to the caller. The boolean argument will be True4 if this call references this context's window, and Falser if it only references shared objects The thread calling this may not be the same creating the context. xRun an OpenGL IO action in this context, that doesn't return any value to the caller. The boolean argument will be True4 if this call references this context's window, and False if it only references shared objects The thread calling this may not be the same creating the context (for finalizers it is most definetly not). tSwap the front and back buffers in the context's default frame buffer. Called from same thread as created context. Get the current size of the context's default framebuffer (which may change if the window is resized). Called from same thread as created context. cDelete this context and close any associated window. Called from same thread as created context. A value representing the context's window. It is recommended that this is an opaque type that doesn't have any exported functions. Instead, provide / actions that are implemented in terms of U to expose any functionality to the user that need a reference the context's window. Run a 2 monad transformer, creating a window (unless the  is  z) that is later destroyed when the action returns. This function will also create a new object space. You need a 5, which is provided by an auxillary package, such as  GPipe-GLFW. Run a E monad transformer inside another one, creating a window (unless the  is  =) that is later destroyed when the action returns. The inner E monad transformer will share object space with the outer one. The J of the outer context will be used in the creation of the inner context. FThis is only used to finalize nonShared objects such as VBOs and FBOs Run 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. Run a S monad, that may have the effect of the context window or textures being drawn to.  May throw a j if a combination of draw images (FBO) used by this render call is unsupported by the graphics driver Return 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. Use the context window handle, which type is specific to the window system used. This handle shouldn't be returned from this function FThis is only used to finalize nonShared objects such as VBOs and FBOs C5*NoneFXMay throw a GPipeException    None 234=KMXThis 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. This 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 . This 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 ). /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. 5An 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. 5An atomic buffer value that represents a vector of 3 as on the host. 5An atomic buffer value that represents a vector of 2 as on the host. =The atomic buffer value that represents a host value of type a. The arrow type for . A  Buffer os b lives in the object space os and contains elements of type b. -Retrieve the number of elements in a buffer. =The class that constraints which types can live in a buffer. [The type a value of this format has when it lives on the host (i.e. normal Haskell world) dAn 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 ... Split up a  a into two  as.  Discard the last component of a  a to get a  a.  Split up a  a into a  a and a B1 a.  Split up a  a into a B1 a and a  a.  Split up a  a into two B1 as. 5Create a buffer with a specified number of elements. >Write a buffer from the host (i.e. the normal Haskell world). =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. u      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR4   !%&S      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRNone!"2346:=BHKM MA compiled shader is just a function that takes an environment and returns a  action ]The monad in which all GPU computations are done. 'Shader os f s a' lives in an object space os and a context with format f%, closing over an environent of type s. qMap the environment to a different environment and run a Shader in that sub environment, returning it's result. 1Conditionally run the effects of a shader when a S value is T something. Like 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. Select one of two  actions based on whether an U value is V or W. Discard all effects of a h action (i.e., dont draw anything) and just return the resulting value. This makes it possible to use a * written for a different context format. Compiles a shader into a g. 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), or if shader evaluates to mzero. Use this to run a shader that doesn't reference the context frame buffer, allowing the same shader to be run in another context with a different context format (but still with same object space). XYZ[\]^_`abcXYZ[\^_`acXYZ[\]^_`abcNone!"2346<=KM_A texture image is a reference to a 2D array of pixels in a texture. Some textures contain one 2 per level of detail while some contain several. 0The type of a color sample made by a texture t rFor some reason, OpenGl doesnt allow explicit lod to be specified for some sampler types, hence this extra GADT. A 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. Used instead of J for shadow samplers. These samplers have specialized sampler values, see ` and friends. !A GADT for sample filters, where ' cannot be used for integer textures. p:Compare two images that doesn't necessarily has same type qRetrieve the 2D size an image defghij     klmnopqr !"#st$%&'()*+,-./uvwxyz{0123456789:;<=>?@ABCDEFG|}HIJKLM~NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwdefghij     klmnopqr !"#st$%&'()*+,-./uvwxyz{0123456789:;<=>?@ABCDEFG|}HIJKLM~NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwdefghij     klmnpoqr !"#st$%&'()*+,-./uvwxyz{0123456789:;<=>?@ABCDEFG|}HIJKLM~NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwNone !"24<=KMxAn array of primitives xAn 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. Numer of indices in an . "A phantom type to indicate that a $ may only be used for instances (in  and ). gA 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 tH indicates whether the vertex array may be used as instances or not. %Retrieve the number of elements in a .  Create a  from a L. The vertex array will have the same number of elements as the buffer, use  and  to make it smaller. Zip two Hs using the function given as first argument. If either of the argument s are restriced to C only, then so will the resulting array be, as depicted by the  type family. takeVertices n a. creates a shorter vertex array by taking the n first elements of the array a. dropVertices 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 . replicateEach 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...}l. This is particulary useful before zipping the array with another that has a different replication rate.  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 aC argument is used to optionally denote a primitive restart index. takeIndices n a- creates a shorter index array by taking the n first indices of the array a. dropIndices n a/ creates a shorter index array by dropping the n first indices of the array a. 2xyz{|}~/xyz{|}~xy~}|{zNone 234=BKMThe arrow type for . oThis class constraints which buffer types can be turned into vertex values, and what type those values have. NThe type the buffer value will be turned into once it becomes a vertex value. fAn 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 use proc ~pattern -> do .... A  t a # is a stream of primitives of type t' where the vertices are values of type a9. You can operate a stream's vertex values using the U 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 x?s instead, as this will create more optimized draw calls. XCreate a primitive stream from a primitive array provided from the shader environment. Like L, but where the vertex and instance IDs are provided as arguments as well. IANone 234=BKM iA float value that doesn't get divided by the interpolated position's w-component during interpolation. A float value that is not interpolated (like integers), and all fragments will instead get the value of the primitive's last vertex sThe 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. The 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. PDefines which side to rasterize. Non triangle primitives only has a front side. qThis class constraints which vertex types can be turned into fragment values, and what type those values have. PThe type the vertex value will be turned into once it becomes a fragment value. hAn 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 use proc ~pattern -> do .... The arrow type for . A  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 A instance (this will result in a shader running on the GPU). 9Rasterize 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 2 parameter and the depth range defined by the  parameter. \Filter out fragments from the stream where the predicate in the first argument evaluates to #, and discard all other fragments. Like d, but where various auto generated information from the rasterization is provided for each vertex. :     '&     NoneBEM"KDenotes the operation that will be performed on the target's stencil value nA bitwise logical operation that will be used to combine colors that has an integral internal representation. ~A factor that the source (fragment) or the destination (target) will be multiplied with before combined with the other in the . The equation used to combine the source (fragment) and the destination (target) after they have been multiplied with their respective s. WA set of blending factors used for the source (fragment) and the destination (target). RDenotes how each fragment's color value should be blended with the target value. A 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. A or 6 , but not :; note the difference with  BlendRgbAlpha restriction). For targets with an internal floating point representation, the fragment value will simply replace the target value. The 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 H needs it. This kind of blending will only be made on colors with a  representation (e.g. A or : , but not 68), integer colors will simply replace the target value. ;The fragment's color will simply replace the target value. 1Indicates whether this color draw should use the . setting given to the draw action. If this is G, the fragment's color value will simply replace the target value. YThe function used to compare the fragment's depth and the depth buffers depth with. E.g. H means "where fragment's depth is less than the buffers current depth". 9 if the depth component should be written to the target. @ for each color component that should be written to the target. 8A monad in which individual color images can be drawn. UDraw color values into a color renderable texture image. Draw 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 r. (OpenGl 3.3 unfortunately doesn't support having different blending settings for different color targets.) Like 8, but performs a depth test on each fragment first. The D monad is then only run for fragments where the depth test passes. Like :, but performs a stencil test on each fragment first. The F monad is then only run for fragments where the stencil test passes. Like [, but performs a stencil test and a depth test (in that order) on each fragment first. The P monad is then only run for fragments where the stencil and depth test passes. Draw color values from a  into the context window. .Perform a depth test for each fragment from a ^ in the context window. This doesn't draw any color values and only affects the depth buffer. .Perform a depth test for each fragment from a Z and write a color value from each fragment that passes the test into the context window. 0Perform a stencil test for each fragment from a ` in the context window. This doesn't draw any color values and only affects the stencil buffer. 0Perform a stencil test for each fragment from a Z and write a color value from each fragment that passes the test into the context window.  OPerform a stencil test and depth test (in that order) for each fragment from a i in the context window. This doesnt draw any color values and only affects the depth and stencil buffer. !OPerform 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 context window. "/Fill a color image with a constant color value #DFill a depth image with a constant depth value (in the range [0,1]) $1Fill a depth image with a constant stencil value %rFill a combined depth stencil image with a constant depth value (in the range [0,1]) and a constant stencil value &BFill the context window's back buffer with a constant color value '^Fill the context window's back depth buffer with a constant depth value (in the range [0,1]) (LFill the context window's back stencil buffer with a constant stencil value )Fill the context window's back depth and stencil buffers with a constant depth value (in the range [0,1]) and a constant stencil value }      ! !"#$%"#$%&'()&'()}      ! !"#$%"#$%&'()&'():      ! !"#$%"#$%&'()&'()None!"2346=BKM*The arrow type for -. +hThis class constraints which buffer types can be loaded as uniforms, and what type those values have. ,^The type the buffer value will be turned into once it becomes a vertex or fragment value (the x parameter is either  or ). -rAn 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 use proc ~pattern -> do .... .Load a uniform value from a  into a t. The argument function is used to retrieve the buffer and the index into this buffer from the shader environment. **++,-.,-./0123456789:;<=>?@ABC **++,-.,-**++,-.,-./0123456789:;<=>?@ABC Safe-Inferred NoneXNOPQRSTUVWXYZ[\]^_`abcdefghijklmnoXNOPQRSTUVWXjklmnoZ[\]^_`abcdefghiY NoneE      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLME   !"#$%&'()*+,-./0123456789:;HIJKLM<=>?@ABCDEFG   None*+,-.+,-*.None/mnopqrstuvwxyz{|}~/mnopqrsyz{|}~tuvwxNone Nonespqrstuvw      !"#$%&'()s !pqrstuvw&'()"#$%      None None  None$xyz{|}~&xy~}|{zNone=KNone=Km  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm\[ZYXWVUTSRQPONMLKJIHGFEDCBA@?>=<;:9876543210/.-,+*)('&%$#"! kjihgfedcba`_^]  lNoneNone!DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl     mnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-. !"#$%&'()*+,-./012345 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~P      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./012345678 9 9 : : ; < = > ?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNMOPQPRPSTTUUVWXYZ[\]./0^123_`abcdefghijklmnopqrstuvwxyz{|}~     4 !"#$%&'()*+,-./0123456789:;<=>?@ABCDBEFBEGBHIBEJBKLBKLBHMBNOBNOBNPBNQBNRBSTBSTBSUBSVBSWBSXBSYBSZBS[B\]B\]B\^B\_B\`B\aB\bB\cB\dB\eB\fB\gB\hB\iB\jB\kB\lBmnBmnBmoBmpBmqBmrBmsBmtBmuBmvBmwBmxBmyBmzBm{Bm|Bm}Bm~BmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBmBCBBBBBBBBBBBBBBBBBBBBBBBBBBBCBCBCBCBCBCBEBEBEBEBEBEBEGBEBEBEBEBEBEBEBEBEBEBCBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB B B B  B  B B B B BBBBBBBBBBBBB  B !B "B #$ GPipe-2.1Graphics.GPipe.FormatGraphics.GPipe.ExprGraphics.GPipe.ContextGraphics.GPipe.ShaderGraphics.GPipe.BufferGraphics.GPipe.UniformGraphics.GPipe.PrimitiveArrayGraphics.GPipe.FrameBufferGraphics.GPipe.SamplerGraphics.GPipe.TextureGraphics.GPipe.PrimitiveStreamGraphics.GPipe.FragmentStream Data.SNMapGraphics.GPipe.Internal.OrphansGraphics.GPipe.Internal.FormatGraphics.GPipe.Internal.ExprGraphics.GPipe.Internal.Context Graphics.GPipe.Internal.CompilerGraphics.GPipe.Internal.BufferGraphics.GPipe.Internal.ShaderGraphics.GPipe.Internal.Texture&Graphics.GPipe.Internal.PrimitiveArray'Graphics.GPipe.Internal.PrimitiveStream&Graphics.GPipe.Internal.FragmentStream#Graphics.GPipe.Internal.FrameBufferGraphics.GPipe.Internal.UniformGraphics.GPipe.OrphansGraphics.GPipe ContextFormat!ContextFormatDepthStencilCombined!ContextFormatDepthStencilSeparateContextFormatStencilContextFormatDepth&ContextFormatColorDepthStencilCombined&ContextFormatColorDepthStencilSeparateContextFormatColorStencilContextFormatColorDepthContextFormatColorContextFormatNoneContextColorFormatStencilRenderableDepthRenderableColorRenderableColorSampleableColor ColorElement TextureFormatFormatDepth32FStencil8Depth24Stencil8 Stencil16Stencil8Stencil4Stencil1Depth32FDepth32Depth24Depth16RGBA32UIRGBA16UIRGBA8UIRGBA32IRGBA16IRGBA8ISRGB8A8RGBA32FRGBA16FRGBA16SRGBA16RGBA12RGB10A2RGBA8SRGBA8RGB5A1RGBA4RGBA2RGB32UIRGB16UIRGB8UIRGBWordRGB32IRGB16IRGB8ISRGB8RGB9E5 R11FG11FB10FRGB32FRGB16FRGB16SRGB16RGB12RGB10RGB8SRGB8RGB5RGB4R3G3B2RG32UIRG16UIRG8UIRG32IRG16IRG8IRG32FRG16FRG16SRG16RG8SRG8R32UIR16UIR8UIR32IR16IR8IR32FR16FR16SR16R8SR8 DepthStencilStencilDepthRGBAWordRGBAInt RGBAFloatRGBIntRGBFloatRGWordRGIntRGFloatRWordRIntRFloat contextBitsConvert ConvertFloat ConvertInt ConvertWordtoFloattoInttoWord FloatingOrdclampsaturatestep smoothstepReal'rsqrtexp2log2floor'ceiling'fract'mod''mix Integral'div'mod' ShaderTypeShaderBaseTypetoBasefromBase ShaderBaseFBoolFWordFIntFFloatVBoolVWordVIntVFloatFVS ifThenElse' ifThenElseifThenwhiledFdxdFdyfwidthGPipeExceptionRenderContextT ContextHandlenewSharedContext contextDoSynccontextDoAsync contextSwapcontextFrameBufferSize contextDelete contextWindowContextFactory runContextTrunSharedContextTswapContextBuffersrendergetContextBuffersSizewithContextWindow BufferColorBPacked NormalizedUniformB4B3B2BToBufferBufferStartPosBuffer bufferLength BufferFormat HostFormattoBuffertoB22toB3toB21toB12toB11 newBuffer writeBuffer copyBufferCompiledShaderShader mapShader maybeShaderguard' chooseShader silenceShader compileShaderwithoutContextImageReferenceValue ColorSample SampleOffset3 SampleOffset2 SampleOffset1 SampleProj SampleLod3' SampleLod2' SampleLod3 SampleLod2 SampleLod1 SampleLod' SampleGrad' SampleBias' SampleAuto' SampleLod SampleGrad SampleBias SampleAuto SamplerCube Sampler3DSampler2DArray Sampler2DSampler1DArray Sampler1DShadowComparisonFunctionAlwaysGequalNotequalGreaterLequalEqualLessNever EdgeMode3 EdgeMode2 SamplerFilterSamplerNearest LodFilter MagFilter MinFilter Anisotropy BorderColorEdgeMode ClampToBorder ClampToEdgeMirrorRepeatFilterLinearNearest StartPos3 StartPos2 StartPos1CubeSideCubeNegZCubePosZCubeNegYCubePosYCubeNegXCubePosXLevelSize3Size2Size1 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 imageSizegetTexture1DImagegetTexture1DArrayImagegetTexture2DImagegetTexture2DArrayImagegetTexture3DImagegetTextureCubeImagePrimitiveArrayPrimitiveTopology PointListLineLoop LineStripLineList TriangleFan TriangleStrip TriangleListPointsLines Triangles IndexArrayindexArrayLength IndexFormatCombine Instances VertexArrayvertexArrayLengthnewVertexArray zipVertices takeVertices dropVertices replicateEach newIndexArray takeIndices dropIndicestoPrimitiveArraytoPrimitiveArrayIndexedtoPrimitiveArrayInstanced toPrimitiveArrayIndexedInstanced InputIndices inputVertexIDinputInstanceIDToVertex VertexInput VertexFormattoVertexPrimitiveStreamtoPrimitiveStreamwithInputIndicesNoPerspectiveVFloat NoPerspective FlatVFloatFlatRasterizedInforasterizedFragCoordrasterizedFrontFacingrasterizedPointCoord DepthRangeminDepthmaxDepthViewPortviewPortLowerLeft viewPortSizeSide FrontAndBackBackFront FragmentInputFragmentFormat toFragment ToFragmentFragmentStreamVPos rasterizefilterFragmentswithRasterizedInfo StencilOpOpInvert OpDecrWrapOpDecr OpIncrWrapOpIncr OpReplaceOpKeepOpZeroLogicOpSetNand OrInverted CopyInverted OrReverseInvertEquivNorOrXorNoop AndInvertedCopy AndReverseAndClearBlendingFactorSrcAlphaSaturateOneMinusConstantAlpha ConstantAlphaOneMinusConstantColor ConstantColorOneMinusDstAlphaDstAlphaOneMinusSrcAlphaSrcAlphaOneMinusDstColorDstColorOneMinusSrcColorSrcColorOneZero BlendEquationMaxMinFuncReverseSubtract FuncSubtractFuncAddBlendingFactorsblendFactorSrcblendFactorDstBlending BlendRgbAlpha NoBlending UseBlending DepthFunction DepthMask ColorMask FrontBackfrontbackDepthStencilOptiondsStencilOptions dsDepthOptionopWhenStencilPassButDepthFail StencilOption stencilTeststencilReferenceopWhenStencilFailopWhenStencilPassstencilReadBitMaskstencilWriteBitMaskStencilOptions DepthOptionContextColorOption FragDepth FragColor DrawColors drawColordraw drawDepth drawStencildrawDepthStencildrawContextColordrawContextDepthdrawContextColorDepthdrawContextStencildrawContextColorStencildrawContextDepthStencildrawContextColorDepthStencilclearColorImageclearDepthImageclearStencilImageclearDepthStencilImageclearContextColorclearContextDepthclearContextStencilclearContextDepthStencil ToUniform UniformInput UniformFormat toUniform getUniform SNMapReaderTSNMapnewSNMapmemoizerunSNMapReaderTmemoizeM$fMonadTransSNMapReaderT $fIfBPoint $fIfBPlucker$fIfBQuaternion$fIfBV4$fIfBV3$fIfBV2$fIfBV1$fIfBV0 $fEqBPoint $fEqBPlucker$fEqBQuaternion$fEqBV4$fEqBV3$fEqBV2$fEqBV1$fEqBV0TFCo:R:BooleanOfPointTFCo:R:BooleanOfQuaternionTFCo:R:BooleanOfPluckerTFCo:R:BooleanOfV4TFCo:R:BooleanOfV3TFCo:R:BooleanOfV2TFCo:R:BooleanOfV1TFCo:R:BooleanOfV0redBits greenBitsblueBits alphaBitsisSrgb clearColortypeStrtypeStr4toColor fromColorsetBorderColor samplerPrefix getGlFormatgetGlInternalFormat colorBits depthBits stencilBitsdepthStencilBits$fContextColorFormatRGBAFloat$fContextColorFormatRGBFloat$fContextColorFormatRGFloat$fContextColorFormatRFloat$fStencilRenderableDepthStencil$fStencilRenderableStencil$fDepthRenderableDepthStencil$fDepthRenderableDepth$fColorRenderableRGBAWord$fColorRenderableRGBAInt$fColorRenderableRGBAFloat$fColorRenderableRGBWord$fColorRenderableRGBInt$fColorRenderableRGBFloat$fColorRenderableRGWord$fColorRenderableRGInt$fColorRenderableRGFloat$fColorRenderableRWord$fColorRenderableRInt$fColorRenderableRFloat$fColorSampleableDepthStencil$fColorSampleableDepth$fColorSampleableRGBAWord$fColorSampleableRGBAInt$fColorSampleableRGBAFloat$fColorSampleableRGBWord$fColorSampleableRGBInt$fColorSampleableRGBFloat$fColorSampleableRGWord$fColorSampleableRGInt$fColorSampleableRGFloat$fColorSampleableRWord$fColorSampleableRInt$fColorSampleableRFloat$fTextureFormatDepthStencil$fTextureFormatStencil$fTextureFormatDepth$fTextureFormatRGBAWord$fTextureFormatRGBAInt$fTextureFormatRGBAFloat$fTextureFormatRGBWord$fTextureFormatRGBInt$fTextureFormatRGBFloat$fTextureFormatRGWord$fTextureFormatRGInt$fTextureFormatRGFloat$fTextureFormatRWord$fTextureFormatRInt$fTextureFormatRFloatghc-prim GHC.TypesFloatDoubleShaderBaseProdShaderBaseUnitShaderBaseBoolShaderBaseWord ShaderBaseIntShaderBaseFloatRValueunS GlobDeclM ExprStateshaderUsedUniformBlocksshaderUsedSamplersshaderUsedInputExprMSType STypeUVec STypeIVecSTypeVecSTypeMatSTypeDyn STypeUInt STypeBoolSTypeInt STypeFloat NextGlobal NextTempVar stypeName stypeSizerunExprMscalarSvec2Svec3Svec4SscalarS'vec2S'vec3S'vec4S'vec2S''vec3S''vec4S'' useVInput useFInput useUniform useSamplergetNexttellAssignmenttellAssignment'discard tellGlobalLn tellGlobalshaderbaseDeclareshaderbaseAssignshaderbaseReturnshaderbaseDeclareDefshaderbaseAssignDefshaderbaseReturnDeftellIfbinfun1fun2fun3fun4postoppreopbinffun1ffun2ffun3fpreopfpostopfbinifun1ipreopibinufun1upreopuifBsfromVfromVec4fromVec3fromVec2 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 $fConvertS $fConvertS0 $fConvertS1 $fConvertWord $fConvertInt$fConvertFloat$fFloatingOrdS$fFloatingOrdDouble$fFloatingOrdFloat $fReal'V4 $fReal'V3 $fReal'V2 $fReal'V1 $fReal'V0$fReal'S $fReal'Double $fReal'Float$fTrivialConjugateS$fTrivialConjugateS0$fTrivialConjugateS1 $fConjugateS $fConjugateS0 $fConjugateS1$fIfBS$fIfBS0$fIfBS1$fIfBS2$fOrdBS$fEqBSTFCo:R:BooleanOfS $fBooleanS $fFloatingS $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 $fFractionalS$fNumS$fNumS0$fNumS1$fShaderType(,,,)x$fShaderType(,,)x$fShaderType(,)x$fShaderTypeV4x$fShaderTypeV3x$fShaderTypeV2x$fShaderTypeV1x$fShaderTypeV0x$fShaderType()x$fShaderTypeSx$fShaderTypeSx0$fShaderTypeSx1$fShaderTypeSx2IOgetContextFinalizerAddergetRenderContextFinalizerAdderFBOCacheVAOCacheFBOKeys fboColorsfboDepth fboStencilFBOKeyfboTnamefboTlayerOrNegIfRendBuff fboTlevelVAOKeyvaoBnamevaoCombBufferOffset vaoComponentsvaoNormvaoDiv ContextDataSharedContextDatasContextDoAsync initGlState liftContextIOaddContextFinalizerliftContextIOAsyncliftContextIOAsyncInWinregisterRenderWriteTexture getFBOKeysnewContextDatasaddContextDataremoveContextDataaddCacheFinalizeraddVAOBufferFinalizeraddFBOTextureFinalizergetContextDatagetRenderContextDatagetVAOsetVAOgetFBOsetFBO$fExceptionGPipeException$fMonadTransContextTcompileAsserter BoundState boundUniforms boundSamplersboundRasterizerN RenderIOStateuniformNameToRenderIOsamplerNameToRenderIOrasterizationNameToRenderIOinputArrayToRenderIOsBindingDrawcall drawcallFBO drawcallNamerasterizationName vertexsSourcefragmentSource usedInputs usedVUniforms usedVSamplers usedFUniforms usedFSamplersnewRenderIOStatemapRenderIOState orderedUnionmakeBindallocate getFBOerrorbaseGHC.WordWord8Word16IntWordunB4unB3unB2bNamebOffsetbStride bSkipElems bInstanceDiv AlignmentMode AlignUnknownAlignPackedIndices AlignUniformAlign4UniformAlignment ToBufferInputBInput bInSkipElemsbInInstanceDivStrideOffset BufferNamebufNamebufElementSize bufBElement bufWriter getGlType peekPixelgetGlPaddedFormatbufSizetoBufferBUnaligned toBufferB toBufferB2 toBufferB3 toBufferB4bufferWriteInternal alignWhen setElemAlignMsetWriterAlignMgetUniformAlignment makeBuffer peekPixel1 peekPixel2 peekPixel3 peekPixel4$fBufferFormatB4$fBufferFormatB40$fBufferFormatB41$fBufferFormatB42$fBufferFormatB43$fBufferFormatB44$fBufferFormatB45$fBufferFormatB3$fBufferFormatB30$fBufferFormatB31$fBufferFormatB32$fBufferFormatB33$fBufferFormatB34$fBufferFormatB35$fBufferFormatB2$fBufferFormatB20$fBufferFormatB21$fBufferFormatB22$fBufferFormatB23$fBufferFormatB$fBufferFormatBPacked$fBufferFormatBPacked0$fBufferFormatB0$fBufferFormatB1$fBufferFormatPlucker$fBufferFormatPoint$fBufferFormatQuaternion$fBufferFormat(,,,)$fBufferFormat(,,)$fBufferFormat(,)$fBufferFormatV4$fBufferFormatV3$fBufferFormatV2$fBufferFormatV1$fBufferFormatV0$fBufferFormatNormalized$fBufferFormatUniform$fArrowToBuffer$fCategory*ToBuffer $fEqBuffer Data.MaybeMaybeJust Data.EitherEitherLeftRightShaderM ShaderStatenewShaderStategetNameaskUniformAlignmentmodifyRenderIO tellDrawcall mapDrawcallthrowFromMaybeTexNameRenderBuffer2D getGlValuesetDefaultTexParams calcLevelSize calcMaxLevelsmakeTexmakeRenderBuffuseTex useTexSyncgetGlColorFormatsetGlPixelStoreRangegenMips getGlCompFuncsetNoShadowMode setShadowFunc setEdgeModesetSamplerFiltersetSamplerFilter' doForSamplert1t3t2t3t3t4addShadowPrefixgetTextureSizesample sampleShadowfetchv1toFv2toFv3toFv4toFiv1toFiv2toFiv3toFciv1toFciv2toFciv3toFpv1toFpv2toFpv3toF sampleFunc fetchFuncoffParamoffNamegetImageBindinggetImageFBOKeyregisterRenderWriteTextureName getGlCubeSide $fEqImageGHC.BaseFunctorgetPrimitiveArrayPrimitiveArrayIntPrimitiveArrayIndexedInstancedPrimitiveArrayInstancedPrimitiveArrayIndexedPrimitiveArraySimple InstanceCountiArrNameoffsetrestart indexType bArrBFunc toGLtopology$fFunctorPrimitiveArray$fMonoidPrimitiveArray$fFunctorVertexArray Data.MonoidMonoidfmapPrimitiveStreamData DrawCallName makeVertexFxmakeVertexFnorm makeVertexF makeVertexIunBnorm$fVertexInputPlucker$fVertexInputPoint$fVertexInputQuaternion$fVertexInputV4$fVertexInputV3$fVertexInputV2$fVertexInputV1$fVertexInputV0$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$fFunctorPrimitiveStream Boolean-0.2.3 Data.BooleantrueFragmentStreamDataRasterizationNameExprPos makeFragmentunFlatunNPersp$fFragmentInputPlucker$fFragmentInputPoint$fFragmentInputQuaternion$fFragmentInput(,,,)$fFragmentInput(,,)$fFragmentInput(,)$fFragmentInputV4$fFragmentInputV3$fFragmentInputV2$fFragmentInputV1$fFragmentInputV0$fFragmentInputS$fFragmentInputS0$fFragmentInputS1"$fFragmentInputNoPerspectiveVFloat$fFragmentInputFlatVFloat$fFragmentInputS2$fFragmentInput()$fFunctorFragmentStreamGHC.Err undefinedFalseTrue runDrawColors makeFBOKeys tellDrawcalls makeDrawcallsetColorsetDepthmake3setGlColorMasksetGlContextColorOptions setGlBlendsetGlDepthOptionssetGlStencilOptionssetGlDepthStencilOptionsusesConstantColorgetGlBlendEquationgetGlBlendFunc getGlLogicOpgetGlStencilOp OffsetToSType buildUDecl makeUniform$fUniformInputPlucker$fUniformInputQuaternion$fUniformInput(,,,)$fUniformInput(,,)$fUniformInput(,)$fUniformInputV4$fUniformInputV3$fUniformInputV2$fUniformInputV1$fUniformInputV0$fUniformInputB4$fUniformInputB40$fUniformInputB41$fUniformInputB3$fUniformInputB30$fUniformInputB31$fUniformInputB2$fUniformInputB20$fUniformInputB21$fUniformInputB$fUniformInputB0$fUniformInputB1>=*>*<=*<*OrdBifBIfB==*/=*EqB BooleanOf||*notBfalse&&*Booleansort2BminBmaxBguardedBcropcondcaseBboolean linear-1.20.1 Linear.MetricMetric Linear.VectorelELinear.EpsilonEpsilonAdditive Linear.V0V0nearZero Linear.V1V1_xR1ex Linear.V2V2_y_xyR2perpeyangle_yx Linear.V3V3_z_xyzR3tripleezcross_zyx_zy_zxy_zx_yzx_yz_yxz_xzy_xz Linear.V4V4_xyzw_wR4vectorpointnormalizePointew_zyxw_zywx_zyw_zxyw_zxwy_zxw_zwyx_zwy_zwxy_zwx_zw_yzxw_yzwx_yzw_yxzw_yxwz_yxw_ywzx_ywz_ywxz_ywx_yw_xzyw_xzwy_xzw_xywz_xyw_xwzy_xwz_xwyz_xwy_xw_wzyx_wzy_wzxy_wzx_wz_wyzx_wyz_wyxz_wyx_wy_wxzy_wxz_wxyz_wxy_wx normalizeLinear.Conjugate conjugate ConjugateLinear.Quaternion Quaternion_k_j_ijk Hamiltonian_i_e Complicatedslerprotatepowekejeiee axisAngleatanqatanhqasinqasinhqacosqacoshqabsidot quadranceqddistancenormsignormzero^+^^-^lerpliftU2liftI2unitsumVscaledouternegatedbasisForbasis^/^**^project Linear.TracetracediagonalTrace Linear.MatrixM44M43M42M34M33M32M24M23M22 transpose translationmkTransformationMatmkTransformation m43_to_m44 m33_to_m44inv44inv33inv22identityfromQuaterniondet44det33det22columnadjoint_m44_m43_m42_m34_m33_m32_m24_m23_m22*!!*!!-!!+!!*!!*!!/!!*TrivialConjugateLinear.Covector runCovectorCovectorLinear.Algebracounitalcomult CoalgebraunitalmultAlgebraLinear.Projection perspectiveortholookAtinversePerspective inverseOrthoinverseInfinitePerspectiveinverseFrustuminfinitePerspectivefrustum$* Linear.Binary putLinear getLinear unitalRepmultRep counitalRep comultRep