-3      !"#$%&'()*+,-./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 { | } ~                                                                    !"#$%&'()*+,-./012 Safe:DR3456789:;<=>?@AB3456789:;<=>?@ABSafeNone %&9:;<=CDR CDEF GHIJKLMNO !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkPQRSTlUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ CDEF GHIJKLMNO= !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkPQRSTlO  CDEF GHIJKLMNOI !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkPQRSTlUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None %&09:;DIORTThe 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.mThis 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)p!A monad in which shaders are run.qXThe 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 q to be runnable.a*The value returned from this monad action.rYClass implementing a window handler that can create openGL contexts, such as GLFW or GLUTscImplementation specific context handler parameters, eg error handling and event processing policiest#Implementation specific window typeuPImplementation specific window parameters, eg initial size and border decorationv5Create a context handler. Called from the main threadw}Delete the context handler. All contexts created from this handler will be deleted using contextDelete prior to calling this.xSCreate 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)yRun 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).zSwap the front and back buffers in the context's default frame buffer. Only ever called from the mainthread (i.e. the thread that called contextHandlerCreate){Get 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 contextHandlerCreate)|Delete a context and close any associated window. Only ever called from the mainthread (i.e. the thread that called contextHandlerCreate)}Run a pG monad, that may have the effect of windows or textures being drawn to. May throw a me if a combination of draw images (FBO) used by this render call is unsupported by the graphics driver~Run a qY monad transformer that encapsulates an object space. You need an implementation of a r5, which is provided by an auxillary package, such as  GPipe-GLFW.Creates a windowBDeletes a window. Any rendering to this window will become a noop.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.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 functionRemoves a VAO entry from all SharedContextDatas when one of the buffers are deleted. This will in turn make the VAO finalizer to be run.Removes a FBO entry from all SharedContextDatas when one of the textures are deleted. This will in turn make the FBO finalizer to be run.cmnopqrstuvwxyz{|}~Dmnopqrstuvwxyz{|}~2mnopqr stuvwxyz{|}~NoneMbMay throw a GPipeException  None 9:;DRTbThis 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.YThe 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.4Create 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.x      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQR5   !"V      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRNone%&9:;<=ADIORTMA compiled shader is just a function that takes an environment and returns a p action[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.oMap 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 G action (i.e., dont draw anything) and just return the resulting value.Compiles 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 m 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)XYZ[\]^_`abpXYZ[\^_`aXYZ[\]^_`abNone %&9;CDRTAn array of primitivesxAn 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 c! 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 c instance. A VertexArray t a has elements of type a, and tD 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 B 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...}i. 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 aA 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.4defghijklmnopqrstuvwx1defghijklmonpqrstudefghijklmnopqrstuvwxNone p} p}None$&NoneDRm = !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklm !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\kjihgfedcba`_^]  lNonemnoqrstuvwxyz{|~q~orstuvwxyz{|mnNoneDRNoneAIOTyWRun a subcomputation in a scope, where nothing memoized inside will be remembered after z{|}~yz|~yz{|}~yNone%&9:;<=CDORT]Provides a common way to convert numeric types to integer and floating point representations.#Convert to a floating point number.=Convert to an integral number, using truncation if necessary.FConvert to an unsigned integral number, using truncation if necessary.5This class provides various order comparing functionsThis 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.Constraint 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.5A base type that this type can convert into. Use the % function on an existing instance of ! to define this in your instance.bConvert this type to the shader base type. Make sure this is as lazy as possible (e.g. use tilde (~) on each pattern match).4Convert back from the shader base type to this type.An opaque type'Phantom type used as first argument in   a7 that denotes that the shader value is a fragment value'Phantom type used as first argument in   a5 that denotes that the shader value is a vertex valueWorks 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.ifThenElse 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) 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) while f g x will iteratively transform x with g as long as f generates .EThe derivative in x using local differencing of the rasterized value.EThe 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.?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~None//None%&9:;<=CDRT_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..The type of a color sample made by a texture tpFor 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.9Compare two images that doesn't necessarily has same typeRetrieve the 2D size an image      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&')(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ NoneX      !"#$%&')(opqrstuvwxyz{|}~X     opqrstuvwxy'()"#$%&! {|}~z NoneE*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnE>=<;:9-./0123?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ijklmn]^_`abcdefgh84765,+*None%&9:;<=DIRTThe arrow type for .eThis 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 useproc ~pattern -> do ....Load 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 9:;DIRTbThe arrow type for .lThis class constraints which buffer types can be turned into vertex values, and what type those values have.MThe 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 useproc ~pattern -> do ....A  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 cT 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.VCreate a primitive stream from a primitive array provided from the shader environment.Like J, but where the vertex and instance IDs are provided as arguments as well.Like , 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.[      !"#$%&'()*+,-./0123456789:;<=>?@ABCS      !"#$%&'()*+,-./0123456789:;<=>?@ABCNone 9:;DIRT gA 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 vertexsThe 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.ODefines which side to rasterize. Non triangle primitives only has a front side.nThis class constraints which vertex types can be turned into fragment values, and what type those values have.OThe 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 useproc ~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 c< 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 1 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 b, but where various auto generated information from the rasterization is provided for each vertex.=DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab'DEFGHIJKL)DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`ab NoneNoneILT"JDenotes the operation that will be performed on the target's stencil valuemA 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.VA set of blending factors used for the source (fragment) and the destination (target).PDenotes how each fragment's color value should be blended with the target value.:The fragment's color 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 c if none of the G needs it. This kind of blending will only be made on colors with a  representation (e.g. / or 6 , but not :7), integer colors will simply replace 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. / or : , but not 6; note the difference with  BlendRgbAlpha restriction). For targets with an internal floating point representation, the fragment value will simply replace the target value.1Indicates whether this color draw should use the . setting given to the draw action. If this is dE, 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. G means "where fragment's depth is less than the buffers current depth".e8 if the depth component should be written to the target.e? for each color component that should be written to the target.6A monad in which individual color images can be drawn.8Draw 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 eo. (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 B monad is then only run for fragments where the depth test passes."Like  :, but performs a stencil test on each fragment first. The D 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 N monad is then only run for fragments where the stencil and depth test passes.$Draw color values from a  into the window.%.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.&.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.'0Perform 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.(0Perform a stencil test for each fragment from a Q and write a color value from each fragment that passes the test into the window.)OPerform 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.*OPerform 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.+.Fill a color image with a constant color value,CFill a depth image with a constant depth value (in the range [0,1])-0Fill a depth image with a constant stencil value.qFill a combined depth stencil image with a constant depth value (in the range [0,1]) and a constant stencil value/9Fill the window's back buffer with a constant color value0TFill the window's back depth buffer with a constant depth value (in the range [0,1])1CFill the window's back stencil buffer with a constant stencil value2~Fill the window's back depth and stencil buffers with a constant depth value (in the range [0,1]) and a constant stencil value     fgh !"#$%&'()*ijklmnopqrst+,-.u/012vwxyz{     fgh !"#$%&'()*ijklmnopqrst+,-.u/012vwxyz{=     fgh !"#$%&'()*ijklmnopqrst+,-.u/012vwxyz{Nones      !"#$%&'()*+,-./012s$%&'()* !"#/012+,-.      None  NoneNone&|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijkl = !"#$%&'()*+,-./0123456789:;<>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&')(*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./012m !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~Z      !"#$%&'()*+,-./01223456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%%&&'()*+,-./0123456789:;<= > ? @ A B C D E F G H I J K L MNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNMOPQPRPSTTUUVWXYZ[M\]^_`abcdefghijklmnoppqqrstuvwxyz{yz|}~      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~  !"#$%PQRSTUMM      !"#$%&''()*+,-./0123456789:;<=>?@ABCDEF)GHIJKLMNOPQRSTUVWXYZ[yz\yz]yz^yz_yz`yzayzbyzcyzdyzeyzfyzgyzhyziyzjyzkyzlyzmyznyzoyzpyzqyzrstustvstvstwsxysxzsx{sx|sx}sx~sxsxsxsxsssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss s s s s sssssssssssssssssss s s!s"s#s$%s$&s$'s$(s$)s$*s$*s$+s$,s$-s./s.0s.0s.1s.2s34s34s56s57s58s59s5:s5;s5<s5=s5>s?@s?AsBCsBDsBEsBFsBGsBHsBIsBJsBKsBLsBMsBMsBNsBOsBPsBQsBRsBSsBTsBUV GPipe-2.2-APERTiAtjcn7PjPghIGoAhGraphics.GPipe.FormatGraphics.GPipe.ContextGraphics.GPipe.ShaderGraphics.GPipe.BufferGraphics.GPipe.UniformGraphics.GPipe.PrimitiveArrayGraphics.GPipe.ExprGraphics.GPipe.FrameBufferGraphics.GPipe.SamplerGraphics.GPipe.TextureGraphics.GPipe.PrimitiveStreamGraphics.GPipe.FragmentStreamGraphics.GPipe.Internal.OrphansGraphics.GPipe.OrphansGraphics.GPipe.Internal.FormatGraphics.GPipe.Internal.Context Graphics.GPipe.Internal.CompilerGraphics.GPipe.Internal.BufferGraphics.GPipe.Internal.Shader&Graphics.GPipe.Internal.PrimitiveArray Data.SNMapGraphics.GPipe.Internal.ExprGraphics.GPipe.Internal.TextureGraphics.GPipe.Internal.Uniform'Graphics.GPipe.Internal.PrimitiveStream&Graphics.GPipe.Internal.FragmentStream#Graphics.GPipe.Internal.FrameBufferGraphics.GPipe 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 toPrimitiveArrayIndexedInstancedConvert ConvertFloat ConvertInt ConvertWordtoFloattoInttoWord FloatingOrdclampsaturatestep smoothstepReal'rsqrtexp2log2floor'ceiling'fract'mod''mix Integral'div'mod' ShaderTypeShaderBaseTypetoBasefromBase ShaderBaseFBoolFWordFIntFFloatVBoolVWordVIntVFloatFVS ifThenElse' ifThenElseifThenwhiledFdxdFdyfwidthImageReferenceValue 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 drawStencildrawDepthStencildrawWindowColordrawWindowDepthdrawWindowColorDepthdrawWindowStencildrawWindowColorStencildrawWindowDepthStencildrawWindowColorDepthStencilclearImageColorclearImageDepthclearImageStencilclearImageDepthStencilclearWindowColorclearWindowDepthclearWindowStencilclearWindowDepthStencil $fIfBPoint $fIfBPlucker$fIfBQuaternion$fIfBV4$fIfBV3$fIfBV2$fIfBV1$fIfBV0 $fEqBPoint $fEqBPlucker$fEqBQuaternion$fEqBV4$fEqBV3$fEqBV2$fEqBV1$fEqBV0redBits 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$fTextureFormatRFloatSharedContextDatasghc-prim GHC.TypesIOaddVAOBufferFinalizeraddFBOTextureFinalizerFBOCacheVAOCacheFBOKeys fboColorsfboDepth fboStencilFBOKeyfboTnamefboTlayerOrNegIfRendBuff fboTlevelVAOKeyvaoBnamevaoCombBufferOffset vaoComponentsvaoNormvaoDiv ContextData getWinName WindowStatewindowContextData boundUniforms boundSamplersboundRasterizerNPerWindowRenderStatePerWindowStateContextDoAsyncName RenderStateperWindowRenderStaterenderWriteTexturesrenderLastUsedWin RenderEnvrenderSharedContextDatanonWindowDoAsyncunRender ContextStatenextNameperWindowState lastUsedWin ContextEnvcontextsharedContextDataregisterRenderWriteTexture initGlStateasSyncgetLastContextWinliftNonWinContextIOliftNonWinContextAsyncIOaddContextFinalizergetLastRenderWin getFBOKeysnewContextDatasaddContextDataremoveContextDataaddCacheFinalizergetVAOsetVAOgetFBOsetFBO$fExceptionGPipeException $fEqWindow$fMonadTransContextTcompileAsserter RenderIOStateuniformNameToRenderIOsamplerNameToRenderIOrasterizationNameToRenderIOinputArrayToRenderIOsBindingDrawcall drawcallFBO drawcallNamerasterizationName vertexsSourcefragmentSource usedInputs usedVUniforms usedVSamplers usedFUniforms usedFSamplersprimStrUBufferSizeWinIdnewRenderIOStatemapRenderIOStatemakeBind orderedUnionallocate getFBOerrorbaseGHC.WordWord8Word16IntWordunB4unB3unB2bNamebOffsetbStride bSkipElems bInstanceDiv AlignmentModeAlign4 AlignUniformAlignPackedIndices AlignUnknownUniformAlignmentBInput 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(,,,,)$fBufferFormat(,,,)$fBufferFormat(,,)$fBufferFormat(,)$fBufferFormat()$fBufferFormatV4$fBufferFormatV3$fBufferFormatV2$fBufferFormatV1$fBufferFormatV0$fBufferFormatNormalized$fBufferFormatUniform$fArrowToBuffer$fCategoryTYPEToBuffer $fEqBufferGHC.BaseMaybeJust Data.EitherEitherLeftRightShaderM ShaderStatenewShaderStategetNameaskUniformAlignmentmodifyRenderIO tellDrawcall mapDrawcallFunctorgetPrimitiveArrayPrimitiveArrayIntPrimitiveArraySimplePrimitiveArrayIndexedPrimitiveArrayInstancedPrimitiveArrayIndexedInstanced BaseVertex InstanceCountiArrNameoffsetrestart indexTypevertexArraySkip bArrBFunc toGLtopology$fFunctorPrimitiveArray$fMonoidPrimitiveArray$fFunctorVertexArrayscopedM SNMapReaderTSNMapnewSNMapmemoizerunSNMapReaderTmemoizeM$fMonadTransSNMapReaderTFloatDouble$Boolean-0.2.4-Jbw7942swS67q7oaeysQFW Data.BooleanifBtrueShaderBaseFloat ShaderBaseIntShaderBaseWordShaderBaseBoolShaderBaseUnitShaderBaseProdRValueunS GlobDeclM ExprStateshaderUsedUniformBlocksshaderUsedSamplersshaderUsedInputExprMSType STypeFloatSTypeInt STypeBool STypeUIntSTypeDynSTypeMatSTypeVec STypeIVec STypeUVec 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 $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$fEqBS $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$fShaderType(,,,)x$fShaderType(,,)x$fShaderType(,)x$fShaderTypeV4x$fShaderTypeV3x$fShaderTypeV2x$fShaderTypeV1x$fShaderTypeV0x$fShaderType()x$fShaderTypeSx$fShaderTypeSx0$fShaderTypeSx1$fShaderTypeSx2TexNameRenderBuffer2D getGlValuesetDefaultTexParams calcLevelSize calcMaxLevelsmakeTexmakeRenderBuffuseTex useTexSyncgetGlColorFormatsetGlPixelStoreRangegenMips getGlCompFuncsetNoShadowMode setShadowFunc setEdgeModesetSamplerFiltersetSamplerFilter' doForSamplert1t3t2t3t3t4addShadowPrefixgetTextureSizesample sampleShadowfetchv1toFv2toFv3toFv4toFiv1toFiv2toFiv3toFciv1toFciv2toFciv3toFpv1toFpv2toFpv3toF sampleFunc fetchFuncoffParamoffNamegetImageBindinggetImageFBOKeyregisterRenderWriteTextureName getGlCubeSide $fEqImage OffsetToSType 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$fUniformInputB1Monoidfmap UniOffsetPrimitiveStreamDataUSize DrawCallName makeVertexFappendmakeBindVertexFxmakeBindVertexFnormmakeBindVertexF makeVertexImakeBindVertexInoWritertoUniformVertexunBnorm$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$fArrowToVertex$fCategoryTYPEToVertex$fFunctorPrimitiveStreamFragmentStreamDataRasterizationNameExprPos makeFragmentunFlatunNPersp$fFragmentInputPlucker$fFragmentInputPoint$fFragmentInputQuaternion$fFragmentInput(,,,,,,)$fFragmentInput(,,,,,)$fFragmentInput(,,,,)$fFragmentInput(,,,)$fFragmentInput(,,)$fFragmentInput(,)$fFragmentInputV4$fFragmentInputV3$fFragmentInputV2$fFragmentInputV1$fFragmentInputV0$fFragmentInputS$fFragmentInputS0$fFragmentInputS1"$fFragmentInputNoPerspectiveVFloat$fFragmentInputFlatVFloat$fFragmentInputS2$fFragmentInput()$fFunctorFragmentStreamGHC.Err undefinedFalseTrue runDrawColors makeFBOKeys tellDrawcalls makeDrawcallsetColorsetDepthmake3setGlColorMasksetGlContextColorOptions setGlBlendsetGlDepthOptionssetGlStencilOptionssetGlDepthStencilOptionsusesConstantColorinWin maybeThrowglTruegetGlBlendEquationgetGlBlendFunc getGlLogicOpgetGlStencilOpsort2BmaxBminBcaseBguardedBcropcondbooleanBooleanfalsenotB&&*||* BooleanOfIfBEqB==*/=*OrdB<*<=*>*>=*$linear-1.20.6-7GMSraBBXwf75Iqz3D0i5lLinear.Covector$*Covector runCovectorLinear.Algebra counitalRep comultRep unitalRepmultRepAlgebramultunital Coalgebracomultcounital Linear.Binary getLinear putLinearLinear.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_ijkLinear.Conjugate Conjugate conjugateTrivialConjugate 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.V0V0 Linear.Metricproject normalizeMetricdot quadranceqddistancenormsignormLinear.EpsilonEpsilonnearZero Linear.VectorouterunitscaledbasisForbasis^/^**^sumVnegatedEelAdditivezero^+^^-^lerpliftU2liftI2