fwgl 0.1.3.0 → 0.1.3.1

raw patch · 2 files changed

+2/−1 lines, 2 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- FWGL: instance Control.Monad.IO.Class.MonadIO FWGL.Effect

- FWGL: instance Control.Monad.IO.Class.MonadIO FWGL.FWGL

- FWGL: instance GHC.Base.Applicative FWGL.Effect

- FWGL: instance GHC.Base.Applicative FWGL.FWGL

- FWGL: instance GHC.Base.Functor FWGL.Effect

- FWGL: instance GHC.Base.Functor FWGL.FWGL

- FWGL: instance GHC.Base.Monad FWGL.Effect

- FWGL: instance GHC.Base.Monad FWGL.FWGL

- FWGL.Geometry: [attributeBuffers] :: GPUBufferGeometry -> [(Buffer, GLUInt, GLUInt -> GL ())]

- FWGL.Geometry: [elementBuffer] :: GPUBufferGeometry -> Buffer

- FWGL.Geometry: [elementCount] :: GPUBufferGeometry -> Int

- FWGL.Geometry: [geometryHash] :: GPUBufferGeometry -> Int

- FWGL.Geometry: [vaoBoundBuffers] :: GPUVAOGeometry -> [Buffer]

- FWGL.Geometry: [vaoElementCount] :: GPUVAOGeometry -> Int

- FWGL.Geometry: [vao] :: GPUVAOGeometry -> VertexArrayObject

- FWGL.Geometry: instance (FWGL.Backend.GLES.GLES, FWGL.Backend.IO.BackendIO) => FWGL.Internal.Resource.Resource (FWGL.Geometry.Geometry i) FWGL.Geometry.GPUBufferGeometry FWGL.Internal.GL.GL

- FWGL.Geometry: instance (FWGL.Backend.GLES.GLES, FWGL.Backend.IO.BackendIO) => FWGL.Internal.Resource.Resource FWGL.Geometry.GPUBufferGeometry FWGL.Geometry.GPUVAOGeometry FWGL.Internal.GL.GL

- FWGL.Geometry: instance Data.Hashable.Class.Hashable (FWGL.Geometry.AttrList is)

- FWGL.Geometry: instance Data.Hashable.Class.Hashable (FWGL.Geometry.Geometry is)

- FWGL.Geometry: instance Data.Hashable.Class.Hashable Data.Vect.Float.Base.Vec2

- FWGL.Geometry: instance Data.Hashable.Class.Hashable Data.Vect.Float.Base.Vec3

- FWGL.Geometry: instance Data.Hashable.Class.Hashable Data.Vect.Float.Base.Vec4

- FWGL.Geometry: instance Data.Hashable.Class.Hashable FWGL.Geometry.GPUBufferGeometry

- FWGL.Geometry: instance GHC.Classes.Eq (FWGL.Geometry.Geometry is)

- FWGL.Geometry: instance GHC.Classes.Eq FWGL.Geometry.GPUBufferGeometry

- FWGL.Geometry.OBJ: [objFaces] :: OBJModel -> [[(Int, Int, Int)]]

- FWGL.Geometry.OBJ: [objNormals] :: OBJModel -> Vector Vec3

- FWGL.Geometry.OBJ: [objUVCoords] :: OBJModel -> Vector Vec2

- FWGL.Geometry.OBJ: [objVertices] :: OBJModel -> Vector Vec3

- FWGL.Geometry.OBJ: instance GHC.Show.Show FWGL.Geometry.OBJ.OBJModel

- FWGL.Graphics.Color: instance Data.Hashable.Class.Hashable FWGL.Graphics.Color.Color

- FWGL.Graphics.Color: instance Foreign.Storable.Storable FWGL.Graphics.Color.Color

- FWGL.Graphics.Color: instance GHC.Classes.Eq FWGL.Graphics.Color.Color

- FWGL.Graphics.Color: instance GHC.Show.Show FWGL.Graphics.Color.Color

- FWGL.Graphics.Draw: instance (FWGL.Backend.GLES.GLES, FWGL.Backend.IO.BackendIO) => FWGL.Internal.Resource.Resource (FWGL.Geometry.Geometry '[]) FWGL.Geometry.GPUVAOGeometry FWGL.Graphics.Types.Draw

- FWGL.Graphics.Draw: instance FWGL.Backend.GLES.GLES => FWGL.Internal.Resource.Resource (FWGL.Shader.Program.LoadedProgram, GHC.Base.String) FWGL.Graphics.Types.UniformLocation FWGL.Internal.GL.GL

- FWGL.Graphics.Generic: instance ((g Data.Type.Equality.== g1) ~ 'GHC.Types.False, FWGL.Graphics.Generic.MemberGlobal g gs) => FWGL.Graphics.Generic.MemberGlobal g (g1 : gs)

- FWGL.Graphics.Generic: instance ((g Data.Type.Equality.== g1) ~ 'GHC.Types.False, FWGL.Graphics.Generic.RemoveGlobal g gs gs') => FWGL.Graphics.Generic.RemoveGlobal g (g1 : gs) (g1 : gs')

- FWGL.Graphics.Generic: instance FWGL.Graphics.Generic.MemberGlobal g (g : gs)

- FWGL.Graphics.Generic: instance FWGL.Graphics.Generic.RemoveGlobal g (g : gs) gs

- FWGL.Graphics.Texture: instance (FWGL.Backend.IO.BackendIO, FWGL.Backend.GLES.GLES) => FWGL.Internal.Resource.Resource FWGL.Graphics.Types.TextureImage FWGL.Graphics.Types.LoadedTexture FWGL.Internal.GL.GL

- FWGL.Graphics.Types: [activeTextures] :: DrawState -> Vector (Maybe Texture)

- FWGL.Graphics.Types: [currentProgram] :: DrawState -> Maybe (Program '[] '[])

- FWGL.Graphics.Types: [gpuBuffers] :: DrawState -> ResMap (Geometry '[]) GPUBufferGeometry

- FWGL.Graphics.Types: [gpuVAOs] :: DrawState -> ResMap (Geometry '[]) GPUVAOGeometry

- FWGL.Graphics.Types: [loadedProgram] :: DrawState -> Maybe LoadedProgram

- FWGL.Graphics.Types: [programs] :: DrawState -> ResMap (Program '[] '[]) LoadedProgram

- FWGL.Graphics.Types: [textureImages] :: DrawState -> ResMap TextureImage LoadedTexture

- FWGL.Graphics.Types: [unDraw] :: Draw a -> StateT DrawState GL a

- FWGL.Graphics.Types: [uniforms] :: DrawState -> ResMap (LoadedProgram, String) UniformLocation

- FWGL.Graphics.Types: [viewportSize] :: DrawState -> (Int, Int)

- FWGL.Graphics.Types: instance Control.Monad.IO.Class.MonadIO FWGL.Graphics.Types.Draw

- FWGL.Graphics.Types: instance Data.Hashable.Class.Hashable FWGL.Graphics.Types.TextureImage

- FWGL.Graphics.Types: instance FWGL.Backend.GLES.GLES => GHC.Classes.Eq FWGL.Graphics.Types.LoadedTexture

- FWGL.Graphics.Types: instance FWGL.Backend.GLES.GLES => GHC.Classes.Eq FWGL.Graphics.Types.Texture

- FWGL.Graphics.Types: instance GHC.Base.Applicative FWGL.Graphics.Types.Draw

- FWGL.Graphics.Types: instance GHC.Base.Functor FWGL.Graphics.Types.Draw

- FWGL.Graphics.Types: instance GHC.Base.Monad FWGL.Graphics.Types.Draw

- FWGL.Graphics.Types: instance GHC.Classes.Eq FWGL.Graphics.Types.LayerType

- FWGL.Graphics.Types: instance GHC.Classes.Eq FWGL.Graphics.Types.TextureImage

- FWGL.Input: [dataButton] :: EventData -> Maybe MouseButton

- FWGL.Input: [dataFramebufferSize] :: EventData -> Maybe (Int, Int)

- FWGL.Input: [dataKey] :: EventData -> Maybe Key

- FWGL.Input: [dataPointer] :: EventData -> Maybe (Int, Int)

- FWGL.Input: [inputCustom] :: Input a -> a

- FWGL.Input: [inputEvents] :: Input a -> HashMap InputEvent [EventData]

- FWGL.Input: instance Data.Hashable.Class.Hashable FWGL.Input.InputEvent

- FWGL.Input: instance GHC.Classes.Eq FWGL.Input.InputEvent

- FWGL.Input: instance GHC.Enum.Enum FWGL.Input.InputEvent

- FWGL.Input: instance GHC.Show.Show FWGL.Input.InputEvent

- FWGL.Internal.GL: instance Control.Monad.IO.Class.MonadIO FWGL.Internal.GL.GL

- FWGL.Internal.GL: instance GHC.Base.Applicative FWGL.Internal.GL.GL

- FWGL.Internal.GL: instance GHC.Base.Functor FWGL.Internal.GL.GL

- FWGL.Internal.GL: instance GHC.Base.Monad FWGL.Internal.GL.GL

- FWGL.Internal.TList: instance (FWGL.Internal.TList.IsSubset xs ys ~ 'GHC.Types.True) => FWGL.Internal.TList.Subset xs ys

- FWGL.Key: instance GHC.Classes.Eq FWGL.Key.Key

- FWGL.Key: instance GHC.Classes.Eq FWGL.Key.MouseButton

- FWGL.Key: instance GHC.Show.Show FWGL.Key.Key

- FWGL.Key: instance GHC.Show.Show FWGL.Key.MouseButton

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU Data.Vect.Float.Base.Vec2 FWGL.Shader.Language.Vec2

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU Data.Vect.Float.Base.Vec3 FWGL.Shader.Language.Vec3

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU Data.Vect.Float.Base.Vec4 FWGL.Shader.Language.Vec4

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU GHC.Types.Float FWGL.Shader.Language.Float

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU Data.Vect.Float.Base.Mat2 FWGL.Shader.Language.Mat2

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU Data.Vect.Float.Base.Mat3 FWGL.Shader.Language.Mat3

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU Data.Vect.Float.Base.Mat4 FWGL.Shader.Language.Mat4

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU Data.Vect.Float.Base.Vec2 FWGL.Shader.Language.Vec2

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU Data.Vect.Float.Base.Vec3 FWGL.Shader.Language.Vec3

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU Data.Vect.Float.Base.Vec4 FWGL.Shader.Language.Vec4

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Internal.GL.ActiveTexture FWGL.Shader.Language.Sampler2D

- FWGL.Shader.CPU: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU GHC.Types.Float FWGL.Shader.Language.Float

- FWGL.Shader.Default2D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU FWGL.Shader.CVec2 FWGL.Shader.Default2D.Position2

- FWGL.Shader.Default2D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU FWGL.Shader.CVec2 FWGL.Shader.Default2D.UV

- FWGL.Shader.Default2D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CFloat FWGL.Shader.Default2D.Depth

- FWGL.Shader.Default2D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CMat3 FWGL.Shader.Default2D.Transform2

- FWGL.Shader.Default2D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CMat3 FWGL.Shader.Default2D.View2

- FWGL.Shader.Default2D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CSampler2D FWGL.Shader.Default2D.Image

- FWGL.Shader.Default2D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default2D.Depth

- FWGL.Shader.Default2D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default2D.Image

- FWGL.Shader.Default2D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default2D.Position2

- FWGL.Shader.Default2D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default2D.Transform2

- FWGL.Shader.Default2D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default2D.UV

- FWGL.Shader.Default2D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default2D.View2

- FWGL.Shader.Default3D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU FWGL.Shader.CVec2 FWGL.Shader.Default3D.UV

- FWGL.Shader.Default3D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU FWGL.Shader.CVec3 FWGL.Shader.Default3D.Normal3

- FWGL.Shader.Default3D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.AttributeCPU FWGL.Shader.CVec3 FWGL.Shader.Default3D.Position3

- FWGL.Shader.Default3D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CMat4 FWGL.Shader.Default3D.Transform3

- FWGL.Shader.Default3D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CMat4 FWGL.Shader.Default3D.View3

- FWGL.Shader.Default3D: instance FWGL.Backend.GLES.GLES => FWGL.Shader.CPU.UniformCPU FWGL.Shader.CSampler2D FWGL.Shader.Default3D.Texture2

- FWGL.Shader.Default3D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default3D.Normal3

- FWGL.Shader.Default3D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default3D.Position3

- FWGL.Shader.Default3D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default3D.Texture2

- FWGL.Shader.Default3D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default3D.Transform3

- FWGL.Shader.Default3D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default3D.UV

- FWGL.Shader.Default3D: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Default3D.View3

- FWGL.Shader.GLSL: instance GHC.Show.Show FWGL.Shader.GLSL.ActionContext

- FWGL.Shader.Language: instance Data.Hashable.Class.Hashable FWGL.Shader.Language.Action

- FWGL.Shader.Language: instance Data.Hashable.Class.Hashable FWGL.Shader.Language.Expr

- FWGL.Shader.Language: instance FWGL.Shader.Language.GenType FWGL.Shader.Language.Float

- FWGL.Shader.Language: instance FWGL.Shader.Language.GenType FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.GenType FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.GenType FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Matrix FWGL.Shader.Language.Mat2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Matrix FWGL.Shader.Language.Mat3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Matrix FWGL.Shader.Language.Mat4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Float FWGL.Shader.Language.Float

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Mat2 FWGL.Shader.Language.Mat2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Mat3 FWGL.Shader.Language.Mat3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Mat4 FWGL.Shader.Language.Mat4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Vec2 FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Vec3 FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Float FWGL.Shader.Language.Vec4 FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat2 FWGL.Shader.Language.Float FWGL.Shader.Language.Mat2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat2 FWGL.Shader.Language.Mat2 FWGL.Shader.Language.Mat2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat2 FWGL.Shader.Language.Vec2 FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat3 FWGL.Shader.Language.Float FWGL.Shader.Language.Mat3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat3 FWGL.Shader.Language.Mat3 FWGL.Shader.Language.Mat3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat3 FWGL.Shader.Language.Vec3 FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat4 FWGL.Shader.Language.Float FWGL.Shader.Language.Mat4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat4 FWGL.Shader.Language.Mat4 FWGL.Shader.Language.Mat4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Mat4 FWGL.Shader.Language.Vec4 FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec2 FWGL.Shader.Language.Float FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec2 FWGL.Shader.Language.Mat2 FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec2 FWGL.Shader.Language.Vec2 FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec3 FWGL.Shader.Language.Float FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec3 FWGL.Shader.Language.Mat3 FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec3 FWGL.Shader.Language.Vec3 FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec4 FWGL.Shader.Language.Float FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec4 FWGL.Shader.Language.Mat4 FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Mul FWGL.Shader.Language.Vec4 FWGL.Shader.Language.Vec4 FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Bool

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Float

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Mat2

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Mat3

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Mat4

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Sampler2D

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Unknown

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Float

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Mat2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Mat3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Mat4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Sum FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance FWGL.Shader.Language.Vector FWGL.Shader.Language.Vec2

- FWGL.Shader.Language: instance FWGL.Shader.Language.Vector FWGL.Shader.Language.Vec3

- FWGL.Shader.Language: instance FWGL.Shader.Language.Vector FWGL.Shader.Language.Vec4

- FWGL.Shader.Language: instance GHC.Classes.Eq FWGL.Shader.Language.Action

- FWGL.Shader.Language: instance GHC.Classes.Eq FWGL.Shader.Language.ContextVarType

- FWGL.Shader.Language: instance GHC.Classes.Eq FWGL.Shader.Language.Expr

- FWGL.Shader.Program: instance (FWGL.Backend.GLES.GLES, FWGL.Backend.IO.BackendIO) => FWGL.Internal.Resource.Resource (FWGL.Shader.Program.Program g i) FWGL.Shader.Program.LoadedProgram FWGL.Internal.GL.GL

- FWGL.Shader.Program: instance Data.Hashable.Class.Hashable (FWGL.Shader.Program.Program gs is)

- FWGL.Shader.Program: instance Data.Hashable.Class.Hashable FWGL.Shader.Program.LoadedProgram

- FWGL.Shader.Program: instance GHC.Classes.Eq (FWGL.Shader.Program.Program gs is)

- FWGL.Shader.Program: instance GHC.Classes.Eq FWGL.Shader.Program.LoadedProgram

- FWGL.Shader.Shader: instance (Data.Typeable.Internal.Typeable x, FWGL.Shader.Shader.AllTypeable xs) => FWGL.Shader.Shader.AllTypeable (x : xs)

- FWGL.Shader.Shader: instance (FWGL.Shader.Language.ShaderType x, Data.Typeable.Internal.Typeable x, FWGL.Shader.Shader.StaticList xs) => FWGL.Shader.Shader.StaticList (x : xs)

- FWGL.Shader.Shader: instance (FWGL.Shader.Language.ShaderType x, Data.Typeable.Internal.Typeable x, FWGL.Shader.Shader.StaticSTList xs, FWGL.Internal.TList.IsMember x xs ~ 'GHC.Types.False) => FWGL.Shader.Shader.StaticSTList (x : xs)

- FWGL.Shader.Shader: instance FWGL.Shader.Shader.AllTypeable '[]

- FWGL.Shader.Shader: instance FWGL.Shader.Shader.StaticList '[]

- FWGL.Shader.Shader: instance FWGL.Shader.Shader.StaticSTList '[]

- FWGL.Shader.Stages: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Stages.FragmentShaderOutput

- FWGL.Shader.Stages: instance FWGL.Shader.Language.ShaderType FWGL.Shader.Stages.VertexShaderOutput

+ FWGL: instance Applicative Effect

+ FWGL: instance Applicative FWGL

+ FWGL: instance Functor Effect

+ FWGL: instance Functor FWGL

+ FWGL: instance Monad Effect

+ FWGL: instance Monad FWGL

+ FWGL: instance MonadIO Effect

+ FWGL: instance MonadIO FWGL

+ FWGL.Geometry: attributeBuffers :: GPUBufferGeometry -> [(Buffer, GLUInt, GLUInt -> GL ())]

+ FWGL.Geometry: elementBuffer :: GPUBufferGeometry -> Buffer

+ FWGL.Geometry: elementCount :: GPUBufferGeometry -> Int

+ FWGL.Geometry: geometryHash :: GPUBufferGeometry -> Int

+ FWGL.Geometry: instance (GLES, BackendIO) => Resource (Geometry i) GPUBufferGeometry GL

+ FWGL.Geometry: instance (GLES, BackendIO) => Resource GPUBufferGeometry GPUVAOGeometry GL

+ FWGL.Geometry: instance Eq (Geometry is)

+ FWGL.Geometry: instance Eq GPUBufferGeometry

+ FWGL.Geometry: instance Hashable (AttrList is)

+ FWGL.Geometry: instance Hashable (Geometry is)

+ FWGL.Geometry: instance Hashable GPUBufferGeometry

+ FWGL.Geometry: instance Hashable Vec2

+ FWGL.Geometry: instance Hashable Vec3

+ FWGL.Geometry: instance Hashable Vec4

+ FWGL.Geometry: vao :: GPUVAOGeometry -> VertexArrayObject

+ FWGL.Geometry: vaoBoundBuffers :: GPUVAOGeometry -> [Buffer]

+ FWGL.Geometry: vaoElementCount :: GPUVAOGeometry -> Int

+ FWGL.Geometry.OBJ: instance Show OBJModel

+ FWGL.Geometry.OBJ: objFaces :: OBJModel -> [[(Int, Int, Int)]]

+ FWGL.Geometry.OBJ: objNormals :: OBJModel -> Vector Vec3

+ FWGL.Geometry.OBJ: objUVCoords :: OBJModel -> Vector Vec2

+ FWGL.Geometry.OBJ: objVertices :: OBJModel -> Vector Vec3

+ FWGL.Graphics.Color: instance Eq Color

+ FWGL.Graphics.Color: instance Hashable Color

+ FWGL.Graphics.Color: instance Show Color

+ FWGL.Graphics.Color: instance Storable Color

+ FWGL.Graphics.Draw: instance (GLES, BackendIO) => Resource (Geometry '[]) GPUVAOGeometry Draw

+ FWGL.Graphics.Draw: instance GLES => Resource (LoadedProgram, String) UniformLocation GL

+ FWGL.Graphics.Generic: instance [overlap ok] ((g == g1) ~ 'False, MemberGlobal g gs) => MemberGlobal g (g1 : gs)

+ FWGL.Graphics.Generic: instance [overlap ok] ((g == g1) ~ 'False, RemoveGlobal g gs gs') => RemoveGlobal g (g1 : gs) (g1 : gs')

+ FWGL.Graphics.Generic: instance [overlap ok] MemberGlobal g (g : gs)

+ FWGL.Graphics.Generic: instance [overlap ok] RemoveGlobal g (g : gs) gs

+ FWGL.Graphics.Texture: instance (BackendIO, GLES) => Resource TextureImage LoadedTexture GL

+ FWGL.Graphics.Types: activeTextures :: DrawState -> Vector (Maybe Texture)

+ FWGL.Graphics.Types: currentProgram :: DrawState -> Maybe (Program [] [])

+ FWGL.Graphics.Types: gpuBuffers :: DrawState -> ResMap (Geometry []) GPUBufferGeometry

+ FWGL.Graphics.Types: gpuVAOs :: DrawState -> ResMap (Geometry []) GPUVAOGeometry

+ FWGL.Graphics.Types: instance Applicative Draw

+ FWGL.Graphics.Types: instance Eq LayerType

+ FWGL.Graphics.Types: instance Eq TextureImage

+ FWGL.Graphics.Types: instance Functor Draw

+ FWGL.Graphics.Types: instance GLES => Eq LoadedTexture

+ FWGL.Graphics.Types: instance GLES => Eq Texture

+ FWGL.Graphics.Types: instance Hashable TextureImage

+ FWGL.Graphics.Types: instance Monad Draw

+ FWGL.Graphics.Types: instance MonadIO Draw

+ FWGL.Graphics.Types: loadedProgram :: DrawState -> Maybe LoadedProgram

+ FWGL.Graphics.Types: programs :: DrawState -> ResMap (Program [] []) LoadedProgram

+ FWGL.Graphics.Types: textureImages :: DrawState -> ResMap TextureImage LoadedTexture

+ FWGL.Graphics.Types: unDraw :: Draw a -> StateT DrawState GL a

+ FWGL.Graphics.Types: uniforms :: DrawState -> ResMap (LoadedProgram, String) UniformLocation

+ FWGL.Graphics.Types: viewportSize :: DrawState -> (Int, Int)

+ FWGL.Input: dataButton :: EventData -> Maybe MouseButton

+ FWGL.Input: dataFramebufferSize :: EventData -> Maybe (Int, Int)

+ FWGL.Input: dataKey :: EventData -> Maybe Key

+ FWGL.Input: dataPointer :: EventData -> Maybe (Int, Int)

+ FWGL.Input: inputCustom :: Input a -> a

+ FWGL.Input: inputEvents :: Input a -> HashMap InputEvent [EventData]

+ FWGL.Input: instance Enum InputEvent

+ FWGL.Input: instance Eq InputEvent

+ FWGL.Input: instance Hashable InputEvent

+ FWGL.Input: instance Show InputEvent

+ FWGL.Internal.GL: instance Applicative GL

+ FWGL.Internal.GL: instance Functor GL

+ FWGL.Internal.GL: instance Monad GL

+ FWGL.Internal.GL: instance MonadIO GL

+ FWGL.Internal.TList: instance IsSubset xs ys ~ 'True => Subset xs ys

+ FWGL.Key: instance Eq Key

+ FWGL.Key: instance Eq MouseButton

+ FWGL.Key: instance Show Key

+ FWGL.Key: instance Show MouseButton

+ FWGL.Shader.CPU: instance GLES => AttributeCPU Float Float

+ FWGL.Shader.CPU: instance GLES => AttributeCPU Vec2 Vec2

+ FWGL.Shader.CPU: instance GLES => AttributeCPU Vec3 Vec3

+ FWGL.Shader.CPU: instance GLES => AttributeCPU Vec4 Vec4

+ FWGL.Shader.CPU: instance GLES => UniformCPU ActiveTexture Sampler2D

+ FWGL.Shader.CPU: instance GLES => UniformCPU Float Float

+ FWGL.Shader.CPU: instance GLES => UniformCPU Mat2 Mat2

+ FWGL.Shader.CPU: instance GLES => UniformCPU Mat3 Mat3

+ FWGL.Shader.CPU: instance GLES => UniformCPU Mat4 Mat4

+ FWGL.Shader.CPU: instance GLES => UniformCPU Vec2 Vec2

+ FWGL.Shader.CPU: instance GLES => UniformCPU Vec3 Vec3

+ FWGL.Shader.CPU: instance GLES => UniformCPU Vec4 Vec4

+ FWGL.Shader.Default2D: instance GLES => AttributeCPU CVec2 Position2

+ FWGL.Shader.Default2D: instance GLES => AttributeCPU CVec2 UV

+ FWGL.Shader.Default2D: instance GLES => UniformCPU CFloat Depth

+ FWGL.Shader.Default2D: instance GLES => UniformCPU CMat3 Transform2

+ FWGL.Shader.Default2D: instance GLES => UniformCPU CMat3 View2

+ FWGL.Shader.Default2D: instance GLES => UniformCPU CSampler2D Image

+ FWGL.Shader.Default2D: instance ShaderType Depth

+ FWGL.Shader.Default2D: instance ShaderType Image

+ FWGL.Shader.Default2D: instance ShaderType Position2

+ FWGL.Shader.Default2D: instance ShaderType Transform2

+ FWGL.Shader.Default2D: instance ShaderType UV

+ FWGL.Shader.Default2D: instance ShaderType View2

+ FWGL.Shader.Default2D: instance Typeable Depth

+ FWGL.Shader.Default2D: instance Typeable Image

+ FWGL.Shader.Default2D: instance Typeable Position2

+ FWGL.Shader.Default2D: instance Typeable Transform2

+ FWGL.Shader.Default2D: instance Typeable UV

+ FWGL.Shader.Default2D: instance Typeable View2

+ FWGL.Shader.Default3D: instance GLES => AttributeCPU CVec2 UV

+ FWGL.Shader.Default3D: instance GLES => AttributeCPU CVec3 Normal3

+ FWGL.Shader.Default3D: instance GLES => AttributeCPU CVec3 Position3

+ FWGL.Shader.Default3D: instance GLES => UniformCPU CMat4 Transform3

+ FWGL.Shader.Default3D: instance GLES => UniformCPU CMat4 View3

+ FWGL.Shader.Default3D: instance GLES => UniformCPU CSampler2D Texture2

+ FWGL.Shader.Default3D: instance ShaderType Normal3

+ FWGL.Shader.Default3D: instance ShaderType Position3

+ FWGL.Shader.Default3D: instance ShaderType Texture2

+ FWGL.Shader.Default3D: instance ShaderType Transform3

+ FWGL.Shader.Default3D: instance ShaderType UV

+ FWGL.Shader.Default3D: instance ShaderType View3

+ FWGL.Shader.Default3D: instance Typeable Normal3

+ FWGL.Shader.Default3D: instance Typeable Position3

+ FWGL.Shader.Default3D: instance Typeable Texture2

+ FWGL.Shader.Default3D: instance Typeable Transform3

+ FWGL.Shader.Default3D: instance Typeable UV

+ FWGL.Shader.Default3D: instance Typeable View3

+ FWGL.Shader.GLSL: instance Show ActionContext

+ FWGL.Shader.Language: instance Eq Action

+ FWGL.Shader.Language: instance Eq ContextVarType

+ FWGL.Shader.Language: instance Eq Expr

+ FWGL.Shader.Language: instance GenType Float

+ FWGL.Shader.Language: instance GenType Vec2

+ FWGL.Shader.Language: instance GenType Vec3

+ FWGL.Shader.Language: instance GenType Vec4

+ FWGL.Shader.Language: instance Hashable Action

+ FWGL.Shader.Language: instance Hashable Expr

+ FWGL.Shader.Language: instance Matrix Mat2

+ FWGL.Shader.Language: instance Matrix Mat3

+ FWGL.Shader.Language: instance Matrix Mat4

+ FWGL.Shader.Language: instance Mul Float Float Float

+ FWGL.Shader.Language: instance Mul Float Mat2 Mat2

+ FWGL.Shader.Language: instance Mul Float Mat3 Mat3

+ FWGL.Shader.Language: instance Mul Float Mat4 Mat4

+ FWGL.Shader.Language: instance Mul Float Vec2 Vec2

+ FWGL.Shader.Language: instance Mul Float Vec3 Vec3

+ FWGL.Shader.Language: instance Mul Float Vec4 Vec4

+ FWGL.Shader.Language: instance Mul Mat2 Float Mat2

+ FWGL.Shader.Language: instance Mul Mat2 Mat2 Mat2

+ FWGL.Shader.Language: instance Mul Mat2 Vec2 Vec2

+ FWGL.Shader.Language: instance Mul Mat3 Float Mat3

+ FWGL.Shader.Language: instance Mul Mat3 Mat3 Mat3

+ FWGL.Shader.Language: instance Mul Mat3 Vec3 Vec3

+ FWGL.Shader.Language: instance Mul Mat4 Float Mat4

+ FWGL.Shader.Language: instance Mul Mat4 Mat4 Mat4

+ FWGL.Shader.Language: instance Mul Mat4 Vec4 Vec4

+ FWGL.Shader.Language: instance Mul Vec2 Float Vec2

+ FWGL.Shader.Language: instance Mul Vec2 Mat2 Vec2

+ FWGL.Shader.Language: instance Mul Vec2 Vec2 Vec2

+ FWGL.Shader.Language: instance Mul Vec3 Float Vec3

+ FWGL.Shader.Language: instance Mul Vec3 Mat3 Vec3

+ FWGL.Shader.Language: instance Mul Vec3 Vec3 Vec3

+ FWGL.Shader.Language: instance Mul Vec4 Float Vec4

+ FWGL.Shader.Language: instance Mul Vec4 Mat4 Vec4

+ FWGL.Shader.Language: instance Mul Vec4 Vec4 Vec4

+ FWGL.Shader.Language: instance ShaderType Bool

+ FWGL.Shader.Language: instance ShaderType Float

+ FWGL.Shader.Language: instance ShaderType Mat2

+ FWGL.Shader.Language: instance ShaderType Mat3

+ FWGL.Shader.Language: instance ShaderType Mat4

+ FWGL.Shader.Language: instance ShaderType Sampler2D

+ FWGL.Shader.Language: instance ShaderType Unknown

+ FWGL.Shader.Language: instance ShaderType Vec2

+ FWGL.Shader.Language: instance ShaderType Vec3

+ FWGL.Shader.Language: instance ShaderType Vec4

+ FWGL.Shader.Language: instance Sum Float

+ FWGL.Shader.Language: instance Sum Mat2

+ FWGL.Shader.Language: instance Sum Mat3

+ FWGL.Shader.Language: instance Sum Mat4

+ FWGL.Shader.Language: instance Sum Vec2

+ FWGL.Shader.Language: instance Sum Vec3

+ FWGL.Shader.Language: instance Sum Vec4

+ FWGL.Shader.Language: instance Typeable Bool

+ FWGL.Shader.Language: instance Typeable Float

+ FWGL.Shader.Language: instance Typeable Mat2

+ FWGL.Shader.Language: instance Typeable Mat3

+ FWGL.Shader.Language: instance Typeable Mat4

+ FWGL.Shader.Language: instance Typeable Sampler2D

+ FWGL.Shader.Language: instance Typeable Vec2

+ FWGL.Shader.Language: instance Typeable Vec3

+ FWGL.Shader.Language: instance Typeable Vec4

+ FWGL.Shader.Language: instance Vector Vec2

+ FWGL.Shader.Language: instance Vector Vec3

+ FWGL.Shader.Language: instance Vector Vec4

+ FWGL.Shader.Program: instance (GLES, BackendIO) => Resource (Program g i) LoadedProgram GL

+ FWGL.Shader.Program: instance Eq (Program gs is)

+ FWGL.Shader.Program: instance Eq LoadedProgram

+ FWGL.Shader.Program: instance Hashable (Program gs is)

+ FWGL.Shader.Program: instance Hashable LoadedProgram

+ FWGL.Shader.Shader: instance (ShaderType x, Typeable x, StaticList xs) => StaticList (x : xs)

+ FWGL.Shader.Shader: instance (ShaderType x, Typeable x, StaticSTList xs, IsMember x xs ~ 'False) => StaticSTList (x : xs)

+ FWGL.Shader.Shader: instance (Typeable x, AllTypeable xs) => AllTypeable (x : xs)

+ FWGL.Shader.Shader: instance AllTypeable '[]

+ FWGL.Shader.Shader: instance StaticList '[]

+ FWGL.Shader.Shader: instance StaticSTList '[]

+ FWGL.Shader.Stages: instance ShaderType FragmentShaderOutput

+ FWGL.Shader.Stages: instance ShaderType VertexShaderOutput

+ FWGL.Shader.Stages: instance Typeable FragmentShaderOutput

+ FWGL.Shader.Stages: instance Typeable VertexShaderOutput

- FWGL.Geometry: AttrListNil :: AttrList '[]

+ FWGL.Geometry: AttrListNil :: AttrList []

- FWGL.Graphics.Generic: AttrListNil :: AttrList '[]

+ FWGL.Graphics.Generic: AttrListNil :: AttrList []

- FWGL.Graphics.Generic: geom :: Geometry i -> Object '[] i

+ FWGL.Graphics.Generic: geom :: Geometry i -> Object [] i

- FWGL.Graphics.Generic: modifyGeometry :: (Empty is ~ False) => (Geometry is -> Geometry is') -> Object gs is -> Object gs is'

+ FWGL.Graphics.Generic: modifyGeometry :: Empty is ~ False => (Geometry is -> Geometry is') -> Object gs is -> Object gs is'

- FWGL.Graphics.Generic: nothing :: Object '[] '[]

+ FWGL.Graphics.Generic: nothing :: Object [] []

- FWGL.Graphics.Generic: program :: (ValidVertex vgs vis vos, Valid fgs vos '[], Equal pgs (Union vgs fgs)) => VertexShader vgs vis vos -> FragmentShader fgs vos -> Program pgs vis

+ FWGL.Graphics.Generic: program :: (ValidVertex vgs vis vos, Valid fgs vos [], Equal pgs (Union vgs fgs)) => VertexShader vgs vis vos -> FragmentShader fgs vos -> Program pgs vis

- FWGL.Graphics.Types: DrawState :: Maybe (Program '[] '[]) -> Maybe LoadedProgram -> ResMap (Program '[] '[]) LoadedProgram -> ResMap (LoadedProgram, String) UniformLocation -> ResMap (Geometry '[]) GPUBufferGeometry -> ResMap (Geometry '[]) GPUVAOGeometry -> ResMap TextureImage LoadedTexture -> Vector (Maybe Texture) -> (Int, Int) -> DrawState

+ FWGL.Graphics.Types: DrawState :: Maybe (Program [] []) -> Maybe LoadedProgram -> ResMap (Program [] []) LoadedProgram -> ResMap (LoadedProgram, String) UniformLocation -> ResMap (Geometry []) GPUBufferGeometry -> ResMap (Geometry []) GPUVAOGeometry -> ResMap TextureImage LoadedTexture -> Vector (Maybe Texture) -> (Int, Int) -> DrawState

- FWGL.Graphics.Types: Mesh :: Geometry is -> Object '[] is

+ FWGL.Graphics.Types: Mesh :: Geometry is -> Object [] is

- FWGL.Graphics.Types: NoMesh :: Object '[] '[]

+ FWGL.Graphics.Types: NoMesh :: Object [] []

- FWGL.Internal.TList: type Reverse xs = Reverse' xs '[]

+ FWGL.Internal.TList: type Reverse xs = Reverse' xs []

- FWGL.Shader: N :: STList '[]

+ FWGL.Shader: N :: STList []

- FWGL.Shader: type FragmentShader g i = Shader g i (FragmentShaderOutput : '[])

+ FWGL.Shader: type FragmentShader g i = Shader g i (FragmentShaderOutput : [])

- FWGL.Shader.GLSL: fragmentToGLSL :: Valid g i '[] => FragmentShader g i -> String

+ FWGL.Shader.GLSL: fragmentToGLSL :: Valid g i [] => FragmentShader g i -> String

- FWGL.Shader.Program: program :: (ValidVertex vgs vis vos, Valid fgs vos '[], Equal pgs (Union vgs fgs)) => VertexShader vgs vis vos -> FragmentShader fgs vos -> Program pgs vis

+ FWGL.Shader.Program: program :: (ValidVertex vgs vis vos, Valid fgs vos [], Equal pgs (Union vgs fgs)) => VertexShader vgs vis vos -> FragmentShader fgs vos -> Program pgs vis

- FWGL.Shader.Shader: N :: STList '[]

+ FWGL.Shader.Shader: N :: STList []

- FWGL.Shader.Stages: type FragmentShader g i = Shader g i (FragmentShaderOutput : '[])

+ FWGL.Shader.Stages: type FragmentShader g i = Shader g i (FragmentShaderOutput : [])

Files

FWGL.hs +1/−0
fwgl.cabal +1/−1

FWGL.hs view

@@ -73,6 +73,7 @@  import Data.IORef import qualified Data.HashMap.Strict as H+import Control.Applicative import Control.Concurrent import Control.Monad import Control.Monad.IO.Class

fwgl.cabal view

@@ -1,5 +1,5 @@ name:                fwgl-version:             0.1.3.0+version:             0.1.3.1 synopsis:            Game engine description:         FWGL is a library for interactive 2D and 3D applications and games. It provides a purely functional interface for advanced graphics programming, including a type safe embedded DSL for GPU programming. You are not required to know or use OpenGL directly to work with FWGL, you just need a basic knowledge of what vertex/fragment shaders, uniforms and attributes are (if you are going to make a more advanced use of it). FWGL is aimed at functional reactive programming (with Yampa), but provides a non-reactive interface as well. There are two backends: fwgl-glfw and fwgl-javascript. homepage:            https://github.com/ziocroc/FWGL