--------------------------------------------------------------------------------
-- |
-- Module      :  Graphics.Rendering.OpenGL.GL.BufferObjects
-- Copyright   :  (c) Sven Panne 2002-2019
-- License     :  BSD3
--
-- Maintainer  :  Sven Panne <svenpanne@gmail.com>
-- Stability   :  stable
-- Portability :  portable
--
-- This module corresponds to section 2.9 (Buffer Objects) of the OpenGL 2.1
-- specs.
--
--------------------------------------------------------------------------------

module Graphics.Rendering.OpenGL.GL.BufferObjects (
   -- * Buffer Objects
   BufferObject,

   -- * Binding Buffer Objects
   BufferTarget(..), bindBuffer, arrayBufferBinding,
   vertexAttribArrayBufferBinding,

   -- * Handling Buffer Data
   BufferUsage(..), bufferData, TransferDirection(..), bufferSubData,

   -- * Mapping Buffer Objects
   BufferAccess(..), MappingFailure(..), withMappedBuffer,
   mapBuffer, unmapBuffer,
   bufferAccess, bufferMapped,

   MapBufferUsage(..), Offset, Length,
   mapBufferRange, flushMappedBufferRange,

   -- * Indexed Buffer manipulation
   BufferIndex,
   RangeStartIndex, RangeSize,
   BufferRange,
   IndexedBufferTarget(..),
   bindBufferBase, bindBufferRange,
   indexedBufferStart, indexedBufferSize
) where

import Control.Monad.IO.Class
import Data.Maybe ( fromMaybe )
import Data.ObjectName
import Data.StateVar
import Foreign.Marshal.Array ( allocaArray, peekArray, withArrayLen )
import Foreign.Marshal.Utils ( with )
import Foreign.Ptr ( Ptr, nullPtr )
import Graphics.Rendering.OpenGL.GL.DebugOutput
import Graphics.Rendering.OpenGL.GL.Exception
import Graphics.Rendering.OpenGL.GL.GLboolean
import Graphics.Rendering.OpenGL.GL.PeekPoke
import Graphics.Rendering.OpenGL.GL.QueryUtils
import Graphics.Rendering.OpenGL.GL.VertexArrays
import Graphics.Rendering.OpenGL.GLU.ErrorsInternal
import Graphics.GL

--------------------------------------------------------------------------------

newtype BufferObject = BufferObject { BufferObject -> GLuint
bufferID :: GLuint }
   deriving ( BufferObject -> BufferObject -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferObject -> BufferObject -> Bool
$c/= :: BufferObject -> BufferObject -> Bool
== :: BufferObject -> BufferObject -> Bool
$c== :: BufferObject -> BufferObject -> Bool
Eq, Eq BufferObject
BufferObject -> BufferObject -> Bool
BufferObject -> BufferObject -> Ordering
BufferObject -> BufferObject -> BufferObject
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BufferObject -> BufferObject -> BufferObject
$cmin :: BufferObject -> BufferObject -> BufferObject
max :: BufferObject -> BufferObject -> BufferObject
$cmax :: BufferObject -> BufferObject -> BufferObject
>= :: BufferObject -> BufferObject -> Bool
$c>= :: BufferObject -> BufferObject -> Bool
> :: BufferObject -> BufferObject -> Bool
$c> :: BufferObject -> BufferObject -> Bool
<= :: BufferObject -> BufferObject -> Bool
$c<= :: BufferObject -> BufferObject -> Bool
< :: BufferObject -> BufferObject -> Bool
$c< :: BufferObject -> BufferObject -> Bool
compare :: BufferObject -> BufferObject -> Ordering
$ccompare :: BufferObject -> BufferObject -> Ordering
Ord, Int -> BufferObject -> ShowS
[BufferObject] -> ShowS
BufferObject -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferObject] -> ShowS
$cshowList :: [BufferObject] -> ShowS
show :: BufferObject -> String
$cshow :: BufferObject -> String
showsPrec :: Int -> BufferObject -> ShowS
$cshowsPrec :: Int -> BufferObject -> ShowS
Show )

--------------------------------------------------------------------------------

instance ObjectName BufferObject where
   isObjectName :: forall (m :: * -> *). MonadIO m => BufferObject -> m Bool
isObjectName = forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. (Eq a, Num a) => a -> Bool
unmarshalGLboolean forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadIO m => GLuint -> m GLboolean
glIsBuffer forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferObject -> GLuint
bufferID

   deleteObjectNames :: forall (m :: * -> *). MonadIO m => [BufferObject] -> m ()
deleteObjectNames [BufferObject]
bufferObjects =
      forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. Storable a => [a] -> (Int -> Ptr a -> IO b) -> IO b
withArrayLen (forall a b. (a -> b) -> [a] -> [b]
map BufferObject -> GLuint
bufferID [BufferObject]
bufferObjects) forall a b. (a -> b) -> a -> b
$
         forall (m :: * -> *). MonadIO m => GLint -> Ptr GLuint -> m ()
glDeleteBuffers forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral

instance GeneratableObjectName BufferObject where
   genObjectNames :: forall (m :: * -> *). MonadIO m => Int -> m [BufferObject]
genObjectNames Int
n =
      forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. Storable a => Int -> (Ptr a -> IO b) -> IO b
allocaArray Int
n forall a b. (a -> b) -> a -> b
$ \Ptr GLuint
buf -> do
        forall (m :: * -> *). MonadIO m => GLint -> Ptr GLuint -> m ()
glGenBuffers (forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n) Ptr GLuint
buf
        forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b. (a -> b) -> [a] -> [b]
map GLuint -> BufferObject
BufferObject) forall a b. (a -> b) -> a -> b
$ forall a. Storable a => Int -> Ptr a -> IO [a]
peekArray Int
n Ptr GLuint
buf

instance CanBeLabeled BufferObject where
   objectLabel :: BufferObject -> StateVar (Maybe String)
objectLabel = GLuint -> GLuint -> StateVar (Maybe String)
objectNameLabel GLuint
GL_BUFFER forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferObject -> GLuint
bufferID

--------------------------------------------------------------------------------

data BufferTarget =
     ArrayBuffer
   | AtomicCounterBuffer
   | CopyReadBuffer
   | CopyWriteBuffer
   | DispatchIndirectBuffer
   | DrawIndirectBuffer
   | ElementArrayBuffer
   | PixelPackBuffer
   | PixelUnpackBuffer
   | QueryBuffer
   | ShaderStorageBuffer
   | TextureBuffer
   | TransformFeedbackBuffer
   | UniformBuffer
   deriving ( BufferTarget -> BufferTarget -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferTarget -> BufferTarget -> Bool
$c/= :: BufferTarget -> BufferTarget -> Bool
== :: BufferTarget -> BufferTarget -> Bool
$c== :: BufferTarget -> BufferTarget -> Bool
Eq, Eq BufferTarget
BufferTarget -> BufferTarget -> Bool
BufferTarget -> BufferTarget -> Ordering
BufferTarget -> BufferTarget -> BufferTarget
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BufferTarget -> BufferTarget -> BufferTarget
$cmin :: BufferTarget -> BufferTarget -> BufferTarget
max :: BufferTarget -> BufferTarget -> BufferTarget
$cmax :: BufferTarget -> BufferTarget -> BufferTarget
>= :: BufferTarget -> BufferTarget -> Bool
$c>= :: BufferTarget -> BufferTarget -> Bool
> :: BufferTarget -> BufferTarget -> Bool
$c> :: BufferTarget -> BufferTarget -> Bool
<= :: BufferTarget -> BufferTarget -> Bool
$c<= :: BufferTarget -> BufferTarget -> Bool
< :: BufferTarget -> BufferTarget -> Bool
$c< :: BufferTarget -> BufferTarget -> Bool
compare :: BufferTarget -> BufferTarget -> Ordering
$ccompare :: BufferTarget -> BufferTarget -> Ordering
Ord, Int -> BufferTarget -> ShowS
[BufferTarget] -> ShowS
BufferTarget -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferTarget] -> ShowS
$cshowList :: [BufferTarget] -> ShowS
show :: BufferTarget -> String
$cshow :: BufferTarget -> String
showsPrec :: Int -> BufferTarget -> ShowS
$cshowsPrec :: Int -> BufferTarget -> ShowS
Show )

marshalBufferTarget :: BufferTarget -> GLenum
marshalBufferTarget :: BufferTarget -> GLuint
marshalBufferTarget BufferTarget
x = case BufferTarget
x of
   BufferTarget
ArrayBuffer -> GLuint
GL_ARRAY_BUFFER
   BufferTarget
AtomicCounterBuffer -> GLuint
GL_ATOMIC_COUNTER_BUFFER
   BufferTarget
CopyReadBuffer -> GLuint
GL_COPY_READ_BUFFER
   BufferTarget
CopyWriteBuffer -> GLuint
GL_COPY_WRITE_BUFFER
   BufferTarget
DispatchIndirectBuffer -> GLuint
GL_DISPATCH_INDIRECT_BUFFER
   BufferTarget
DrawIndirectBuffer -> GLuint
GL_DRAW_INDIRECT_BUFFER
   BufferTarget
ElementArrayBuffer -> GLuint
GL_ELEMENT_ARRAY_BUFFER
   BufferTarget
PixelPackBuffer -> GLuint
GL_PIXEL_PACK_BUFFER
   BufferTarget
PixelUnpackBuffer -> GLuint
GL_PIXEL_UNPACK_BUFFER
   BufferTarget
QueryBuffer -> GLuint
GL_QUERY_BUFFER
   BufferTarget
ShaderStorageBuffer -> GLuint
GL_SHADER_STORAGE_BUFFER
   BufferTarget
TextureBuffer -> GLuint
GL_TEXTURE_BUFFER
   BufferTarget
TransformFeedbackBuffer -> GLuint
GL_TRANSFORM_FEEDBACK_BUFFER
   BufferTarget
UniformBuffer -> GLuint
GL_UNIFORM_BUFFER

bufferTargetToGetPName :: BufferTarget -> PName1I
bufferTargetToGetPName :: BufferTarget -> PName1I
bufferTargetToGetPName BufferTarget
x = case BufferTarget
x of
   BufferTarget
ArrayBuffer -> PName1I
GetArrayBufferBinding
   BufferTarget
AtomicCounterBuffer -> PName1I
GetAtomicCounterBufferBinding
   BufferTarget
CopyReadBuffer -> PName1I
GetCopyReadBufferBinding
   BufferTarget
CopyWriteBuffer -> PName1I
GetCopyWriteBufferBinding
   BufferTarget
DispatchIndirectBuffer -> PName1I
GetDispatchIndirectBufferBinding
   BufferTarget
DrawIndirectBuffer -> PName1I
GetDrawIndirectBufferBinding
   BufferTarget
ElementArrayBuffer -> PName1I
GetElementArrayBufferBinding
   BufferTarget
PixelPackBuffer -> PName1I
GetPixelPackBufferBinding
   BufferTarget
PixelUnpackBuffer -> PName1I
GetPixelUnpackBufferBinding
   BufferTarget
QueryBuffer -> PName1I
GetQueryBufferBinding
   BufferTarget
ShaderStorageBuffer -> PName1I
GetShaderStorageBufferBinding
   BufferTarget
TextureBuffer -> PName1I
GetTextureBindingBuffer
   BufferTarget
TransformFeedbackBuffer -> PName1I
GetTransformFeedbackBufferBinding
   BufferTarget
UniformBuffer -> PName1I
GetUniformBufferBinding

--------------------------------------------------------------------------------

data BufferUsage =
     StreamDraw
   | StreamRead
   | StreamCopy
   | StaticDraw
   | StaticRead
   | StaticCopy
   | DynamicDraw
   | DynamicRead
   | DynamicCopy
   deriving ( BufferUsage -> BufferUsage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferUsage -> BufferUsage -> Bool
$c/= :: BufferUsage -> BufferUsage -> Bool
== :: BufferUsage -> BufferUsage -> Bool
$c== :: BufferUsage -> BufferUsage -> Bool
Eq, Eq BufferUsage
BufferUsage -> BufferUsage -> Bool
BufferUsage -> BufferUsage -> Ordering
BufferUsage -> BufferUsage -> BufferUsage
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BufferUsage -> BufferUsage -> BufferUsage
$cmin :: BufferUsage -> BufferUsage -> BufferUsage
max :: BufferUsage -> BufferUsage -> BufferUsage
$cmax :: BufferUsage -> BufferUsage -> BufferUsage
>= :: BufferUsage -> BufferUsage -> Bool
$c>= :: BufferUsage -> BufferUsage -> Bool
> :: BufferUsage -> BufferUsage -> Bool
$c> :: BufferUsage -> BufferUsage -> Bool
<= :: BufferUsage -> BufferUsage -> Bool
$c<= :: BufferUsage -> BufferUsage -> Bool
< :: BufferUsage -> BufferUsage -> Bool
$c< :: BufferUsage -> BufferUsage -> Bool
compare :: BufferUsage -> BufferUsage -> Ordering
$ccompare :: BufferUsage -> BufferUsage -> Ordering
Ord, Int -> BufferUsage -> ShowS
[BufferUsage] -> ShowS
BufferUsage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferUsage] -> ShowS
$cshowList :: [BufferUsage] -> ShowS
show :: BufferUsage -> String
$cshow :: BufferUsage -> String
showsPrec :: Int -> BufferUsage -> ShowS
$cshowsPrec :: Int -> BufferUsage -> ShowS
Show )

marshalBufferUsage :: BufferUsage -> GLenum
marshalBufferUsage :: BufferUsage -> GLuint
marshalBufferUsage BufferUsage
x = case BufferUsage
x of
   BufferUsage
StreamDraw -> GLuint
GL_STREAM_DRAW
   BufferUsage
StreamRead -> GLuint
GL_STREAM_READ
   BufferUsage
StreamCopy -> GLuint
GL_STREAM_COPY
   BufferUsage
StaticDraw -> GLuint
GL_STATIC_DRAW
   BufferUsage
StaticRead -> GLuint
GL_STATIC_READ
   BufferUsage
StaticCopy -> GLuint
GL_STATIC_COPY
   BufferUsage
DynamicDraw -> GLuint
GL_DYNAMIC_DRAW
   BufferUsage
DynamicRead -> GLuint
GL_DYNAMIC_READ
   BufferUsage
DynamicCopy -> GLuint
GL_DYNAMIC_COPY

unmarshalBufferUsage :: GLenum -> BufferUsage
unmarshalBufferUsage :: GLuint -> BufferUsage
unmarshalBufferUsage GLuint
x
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_STREAM_DRAW = BufferUsage
StreamDraw
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_STREAM_READ = BufferUsage
StreamRead
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_STREAM_COPY = BufferUsage
StreamCopy
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_STATIC_DRAW = BufferUsage
StaticDraw
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_STATIC_READ = BufferUsage
StaticRead
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_STATIC_COPY = BufferUsage
StaticCopy
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_DYNAMIC_DRAW = BufferUsage
DynamicDraw
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_DYNAMIC_READ = BufferUsage
DynamicRead
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_DYNAMIC_COPY = BufferUsage
DynamicCopy
   | Bool
otherwise = forall a. HasCallStack => String -> a
error (String
"unmarshalBufferUsage: illegal value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show GLuint
x)

--------------------------------------------------------------------------------

data BufferAccess =
     ReadOnly
   | WriteOnly
   | ReadWrite
   deriving ( BufferAccess -> BufferAccess -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BufferAccess -> BufferAccess -> Bool
$c/= :: BufferAccess -> BufferAccess -> Bool
== :: BufferAccess -> BufferAccess -> Bool
$c== :: BufferAccess -> BufferAccess -> Bool
Eq, Eq BufferAccess
BufferAccess -> BufferAccess -> Bool
BufferAccess -> BufferAccess -> Ordering
BufferAccess -> BufferAccess -> BufferAccess
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: BufferAccess -> BufferAccess -> BufferAccess
$cmin :: BufferAccess -> BufferAccess -> BufferAccess
max :: BufferAccess -> BufferAccess -> BufferAccess
$cmax :: BufferAccess -> BufferAccess -> BufferAccess
>= :: BufferAccess -> BufferAccess -> Bool
$c>= :: BufferAccess -> BufferAccess -> Bool
> :: BufferAccess -> BufferAccess -> Bool
$c> :: BufferAccess -> BufferAccess -> Bool
<= :: BufferAccess -> BufferAccess -> Bool
$c<= :: BufferAccess -> BufferAccess -> Bool
< :: BufferAccess -> BufferAccess -> Bool
$c< :: BufferAccess -> BufferAccess -> Bool
compare :: BufferAccess -> BufferAccess -> Ordering
$ccompare :: BufferAccess -> BufferAccess -> Ordering
Ord, Int -> BufferAccess -> ShowS
[BufferAccess] -> ShowS
BufferAccess -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BufferAccess] -> ShowS
$cshowList :: [BufferAccess] -> ShowS
show :: BufferAccess -> String
$cshow :: BufferAccess -> String
showsPrec :: Int -> BufferAccess -> ShowS
$cshowsPrec :: Int -> BufferAccess -> ShowS
Show )

marshalBufferAccess :: BufferAccess -> GLenum
marshalBufferAccess :: BufferAccess -> GLuint
marshalBufferAccess BufferAccess
x = case BufferAccess
x of
   BufferAccess
ReadOnly -> GLuint
GL_READ_ONLY
   BufferAccess
WriteOnly -> GLuint
GL_WRITE_ONLY
   BufferAccess
ReadWrite -> GLuint
GL_READ_WRITE

unmarshalBufferAccess :: GLenum -> BufferAccess
unmarshalBufferAccess :: GLuint -> BufferAccess
unmarshalBufferAccess GLuint
x
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_READ_ONLY = BufferAccess
ReadOnly
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_WRITE_ONLY = BufferAccess
WriteOnly
   | GLuint
x forall a. Eq a => a -> a -> Bool
== GLuint
GL_READ_WRITE = BufferAccess
ReadWrite
   | Bool
otherwise = forall a. HasCallStack => String -> a
error (String
"unmarshalBufferAccess: illegal value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> String
show GLuint
x)

--------------------------------------------------------------------------------

bindBuffer :: BufferTarget -> StateVar (Maybe BufferObject)
bindBuffer :: BufferTarget -> StateVar (Maybe BufferObject)
bindBuffer BufferTarget
t = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (BufferTarget -> IO (Maybe BufferObject)
getBindBuffer BufferTarget
t) (BufferTarget -> Maybe BufferObject -> IO ()
setBindBuffer BufferTarget
t)

getBindBuffer :: BufferTarget -> IO (Maybe BufferObject)
getBindBuffer :: BufferTarget -> IO (Maybe BufferObject)
getBindBuffer = forall a. (a -> PName1I) -> a -> IO (Maybe BufferObject)
bufferQuery BufferTarget -> PName1I
bufferTargetToGetPName

bufferQuery :: (a -> PName1I) -> a -> IO (Maybe BufferObject)
bufferQuery :: forall a. (a -> PName1I) -> a -> IO (Maybe BufferObject)
bufferQuery a -> PName1I
func a
t = do
   BufferObject
buf <- forall p a. GetPName1I p => (GLint -> a) -> p -> IO a
getInteger1 (GLuint -> BufferObject
BufferObject forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) (a -> PName1I
func a
t)
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if BufferObject
buf forall a. Eq a => a -> a -> Bool
== BufferObject
noBufferObject then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just BufferObject
buf

noBufferObject :: BufferObject
noBufferObject :: BufferObject
noBufferObject = GLuint -> BufferObject
BufferObject GLuint
0

setBindBuffer :: BufferTarget -> Maybe BufferObject -> IO ()
setBindBuffer :: BufferTarget -> Maybe BufferObject -> IO ()
setBindBuffer BufferTarget
t =
   forall (m :: * -> *). MonadIO m => GLuint -> GLuint -> m ()
glBindBuffer (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t) forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferObject -> GLuint
bufferID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe BufferObject
noBufferObject

clientArrayTypeToGetPName :: ClientArrayType -> PName1I
clientArrayTypeToGetPName :: ClientArrayType -> PName1I
clientArrayTypeToGetPName ClientArrayType
x = case ClientArrayType
x of
   ClientArrayType
VertexArray -> PName1I
GetVertexArrayBufferBinding
   ClientArrayType
NormalArray -> PName1I
GetNormalArrayBufferBinding
   ClientArrayType
ColorArray -> PName1I
GetColorArrayBufferBinding
   ClientArrayType
IndexArray -> PName1I
GetIndexArrayBufferBinding
   ClientArrayType
TextureCoordArray -> PName1I
GetTextureCoordArrayBufferBinding
   ClientArrayType
EdgeFlagArray -> PName1I
GetEdgeFlagArrayBufferBinding
   ClientArrayType
FogCoordArray -> PName1I
GetFogCoordArrayBufferBinding
   ClientArrayType
SecondaryColorArray -> PName1I
GetSecondaryColorArrayBufferBinding
   ClientArrayType
MatrixIndexArray -> forall a. HasCallStack => String -> a
error String
"clientArrayTypeToGetPName: impossible"

arrayBufferBinding :: ClientArrayType -> GettableStateVar (Maybe BufferObject)
arrayBufferBinding :: ClientArrayType -> IO (Maybe BufferObject)
arrayBufferBinding ClientArrayType
t =
   forall a. IO a -> IO a
makeGettableStateVar forall a b. (a -> b) -> a -> b
$ case ClientArrayType
t of
      ClientArrayType
MatrixIndexArray -> do IO ()
recordInvalidEnum ; forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
      ClientArrayType
_ -> forall a. (a -> PName1I) -> a -> IO (Maybe BufferObject)
bufferQuery ClientArrayType -> PName1I
clientArrayTypeToGetPName ClientArrayType
t


vertexAttribArrayBufferBinding :: AttribLocation -> GettableStateVar (Maybe BufferObject)
vertexAttribArrayBufferBinding :: AttribLocation -> IO (Maybe BufferObject)
vertexAttribArrayBufferBinding AttribLocation
location =
   forall a. IO a -> IO a
makeGettableStateVar forall a b. (a -> b) -> a -> b
$ do
      BufferObject
buf <- forall b.
(GLint -> b) -> AttribLocation -> GetVertexAttribPName -> IO b
getVertexAttribInteger1 (GLuint -> BufferObject
BufferObject forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) AttribLocation
location GetVertexAttribPName
GetVertexAttribArrayBufferBinding
      forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if BufferObject
buf forall a. Eq a => a -> a -> Bool
== BufferObject
noBufferObject then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just BufferObject
buf

--------------------------------------------------------------------------------

bufferData :: BufferTarget -> StateVar (GLsizeiptr, Ptr a, BufferUsage)
bufferData :: forall a.
BufferTarget -> StateVar (RangeStartIndex, Ptr a, BufferUsage)
bufferData BufferTarget
t = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (forall a. BufferTarget -> IO (RangeStartIndex, Ptr a, BufferUsage)
getBufferData BufferTarget
t) (forall a.
BufferTarget -> (RangeStartIndex, Ptr a, BufferUsage) -> IO ()
setBufferData BufferTarget
t)

getBufferData :: BufferTarget -> IO (GLsizeiptr, Ptr a, BufferUsage)
getBufferData :: forall a. BufferTarget -> IO (RangeStartIndex, Ptr a, BufferUsage)
getBufferData BufferTarget
t = do
   RangeStartIndex
s <- forall a. BufferTarget -> (GLuint -> a) -> GetBufferPName -> IO a
getBufferParameter BufferTarget
t forall a b. (Integral a, Num b) => a -> b
fromIntegral GetBufferPName
GetBufferSize
   Ptr a
p <- forall a. BufferTarget -> IO (Ptr a)
getBufferPointer BufferTarget
t
   BufferUsage
u <- forall a. BufferTarget -> (GLuint -> a) -> GetBufferPName -> IO a
getBufferParameter BufferTarget
t GLuint -> BufferUsage
unmarshalBufferUsage GetBufferPName
GetBufferUsage
   forall (m :: * -> *) a. Monad m => a -> m a
return (RangeStartIndex
s, Ptr a
p, BufferUsage
u)

setBufferData :: BufferTarget -> (GLsizeiptr, Ptr a, BufferUsage) -> IO ()
setBufferData :: forall a.
BufferTarget -> (RangeStartIndex, Ptr a, BufferUsage) -> IO ()
setBufferData BufferTarget
t (RangeStartIndex
s, Ptr a
p, BufferUsage
u) =
   forall (m :: * -> *) a.
MonadIO m =>
GLuint -> RangeStartIndex -> Ptr a -> GLuint -> m ()
glBufferData (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t) RangeStartIndex
s Ptr a
p (BufferUsage -> GLuint
marshalBufferUsage BufferUsage
u)

--------------------------------------------------------------------------------

data TransferDirection =
     ReadFromBuffer
   | WriteToBuffer
   deriving ( TransferDirection -> TransferDirection -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TransferDirection -> TransferDirection -> Bool
$c/= :: TransferDirection -> TransferDirection -> Bool
== :: TransferDirection -> TransferDirection -> Bool
$c== :: TransferDirection -> TransferDirection -> Bool
Eq, Eq TransferDirection
TransferDirection -> TransferDirection -> Bool
TransferDirection -> TransferDirection -> Ordering
TransferDirection -> TransferDirection -> TransferDirection
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: TransferDirection -> TransferDirection -> TransferDirection
$cmin :: TransferDirection -> TransferDirection -> TransferDirection
max :: TransferDirection -> TransferDirection -> TransferDirection
$cmax :: TransferDirection -> TransferDirection -> TransferDirection
>= :: TransferDirection -> TransferDirection -> Bool
$c>= :: TransferDirection -> TransferDirection -> Bool
> :: TransferDirection -> TransferDirection -> Bool
$c> :: TransferDirection -> TransferDirection -> Bool
<= :: TransferDirection -> TransferDirection -> Bool
$c<= :: TransferDirection -> TransferDirection -> Bool
< :: TransferDirection -> TransferDirection -> Bool
$c< :: TransferDirection -> TransferDirection -> Bool
compare :: TransferDirection -> TransferDirection -> Ordering
$ccompare :: TransferDirection -> TransferDirection -> Ordering
Ord, Int -> TransferDirection -> ShowS
[TransferDirection] -> ShowS
TransferDirection -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TransferDirection] -> ShowS
$cshowList :: [TransferDirection] -> ShowS
show :: TransferDirection -> String
$cshow :: TransferDirection -> String
showsPrec :: Int -> TransferDirection -> ShowS
$cshowsPrec :: Int -> TransferDirection -> ShowS
Show )

bufferSubData ::
   BufferTarget -> TransferDirection -> GLintptr -> GLsizeiptr -> Ptr a -> IO ()
bufferSubData :: forall a.
BufferTarget
-> TransferDirection
-> RangeStartIndex
-> RangeStartIndex
-> Ptr a
-> IO ()
bufferSubData BufferTarget
t TransferDirection
WriteToBuffer = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> RangeStartIndex -> RangeStartIndex -> Ptr a -> m ()
glBufferSubData (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t)
bufferSubData BufferTarget
t TransferDirection
ReadFromBuffer = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> RangeStartIndex -> RangeStartIndex -> Ptr a -> m ()
glGetBufferSubData (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t)

--------------------------------------------------------------------------------

data GetBufferPName =
     GetBufferSize
   | GetBufferUsage
   | GetBufferAccess
   | GetBufferMapped

marshalGetBufferPName :: GetBufferPName -> GLenum
marshalGetBufferPName :: GetBufferPName -> GLuint
marshalGetBufferPName GetBufferPName
x = case GetBufferPName
x of
   GetBufferPName
GetBufferSize -> GLuint
GL_BUFFER_SIZE
   GetBufferPName
GetBufferUsage -> GLuint
GL_BUFFER_USAGE
   GetBufferPName
GetBufferAccess -> GLuint
GL_BUFFER_ACCESS
   GetBufferPName
GetBufferMapped -> GLuint
GL_BUFFER_MAPPED

getBufferParameter :: BufferTarget -> (GLenum -> a) -> GetBufferPName -> IO a
getBufferParameter :: forall a. BufferTarget -> (GLuint -> a) -> GetBufferPName -> IO a
getBufferParameter BufferTarget
t GLuint -> a
f GetBufferPName
p = forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with GLint
0 forall a b. (a -> b) -> a -> b
$ \Ptr GLint
buf -> do
   forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> Ptr GLint -> m ()
glGetBufferParameteriv (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t)
                          (GetBufferPName -> GLuint
marshalGetBufferPName GetBufferPName
p) Ptr GLint
buf
   forall a b. Storable a => (a -> b) -> Ptr a -> IO b
peek1 (GLuint -> a
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) Ptr GLint
buf

--------------------------------------------------------------------------------

getBufferPointer :: BufferTarget -> IO (Ptr a)
getBufferPointer :: forall a. BufferTarget -> IO (Ptr a)
getBufferPointer BufferTarget
t = forall a b. Storable a => a -> (Ptr a -> IO b) -> IO b
with forall a. Ptr a
nullPtr forall a b. (a -> b) -> a -> b
$ \Ptr (Ptr a)
buf -> do
   forall (m :: * -> *) a.
MonadIO m =>
GLuint -> GLuint -> Ptr (Ptr a) -> m ()
glGetBufferPointerv (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t) GLuint
GL_BUFFER_MAP_POINTER Ptr (Ptr a)
buf
   forall a b. Storable a => (a -> b) -> Ptr a -> IO b
peek1 forall a. a -> a
id Ptr (Ptr a)
buf

--------------------------------------------------------------------------------

data MappingFailure =
     MappingFailed
   | UnmappingFailed
   deriving ( MappingFailure -> MappingFailure -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MappingFailure -> MappingFailure -> Bool
$c/= :: MappingFailure -> MappingFailure -> Bool
== :: MappingFailure -> MappingFailure -> Bool
$c== :: MappingFailure -> MappingFailure -> Bool
Eq, Eq MappingFailure
MappingFailure -> MappingFailure -> Bool
MappingFailure -> MappingFailure -> Ordering
MappingFailure -> MappingFailure -> MappingFailure
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MappingFailure -> MappingFailure -> MappingFailure
$cmin :: MappingFailure -> MappingFailure -> MappingFailure
max :: MappingFailure -> MappingFailure -> MappingFailure
$cmax :: MappingFailure -> MappingFailure -> MappingFailure
>= :: MappingFailure -> MappingFailure -> Bool
$c>= :: MappingFailure -> MappingFailure -> Bool
> :: MappingFailure -> MappingFailure -> Bool
$c> :: MappingFailure -> MappingFailure -> Bool
<= :: MappingFailure -> MappingFailure -> Bool
$c<= :: MappingFailure -> MappingFailure -> Bool
< :: MappingFailure -> MappingFailure -> Bool
$c< :: MappingFailure -> MappingFailure -> Bool
compare :: MappingFailure -> MappingFailure -> Ordering
$ccompare :: MappingFailure -> MappingFailure -> Ordering
Ord, Int -> MappingFailure -> ShowS
[MappingFailure] -> ShowS
MappingFailure -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MappingFailure] -> ShowS
$cshowList :: [MappingFailure] -> ShowS
show :: MappingFailure -> String
$cshow :: MappingFailure -> String
showsPrec :: Int -> MappingFailure -> ShowS
$cshowsPrec :: Int -> MappingFailure -> ShowS
Show )

-- | Convenience function for an exception-safe combination of 'mapBuffer' and
-- 'unmapBuffer'.
withMappedBuffer :: BufferTarget -> BufferAccess -> (Ptr a -> IO b) -> (MappingFailure -> IO b) -> IO b
withMappedBuffer :: forall a b.
BufferTarget
-> BufferAccess
-> (Ptr a -> IO b)
-> (MappingFailure -> IO b)
-> IO b
withMappedBuffer BufferTarget
t BufferAccess
a Ptr a -> IO b
action MappingFailure -> IO b
err = do
   Maybe (Ptr a)
maybeBuf <- forall a. BufferTarget -> BufferAccess -> IO (Maybe (Ptr a))
mapBuffer BufferTarget
t BufferAccess
a
   case Maybe (Ptr a)
maybeBuf  of
      Maybe (Ptr a)
Nothing -> MappingFailure -> IO b
err MappingFailure
MappingFailed
      Just Ptr a
buf -> do (b
ret, Bool
ok) <- Ptr a -> IO b
action Ptr a
buf forall a b. IO a -> IO b -> IO (a, b)
`finallyRet` BufferTarget -> IO Bool
unmapBuffer BufferTarget
t
                     if Bool
ok
                        then forall (m :: * -> *) a. Monad m => a -> m a
return b
ret
                        else MappingFailure -> IO b
err MappingFailure
UnmappingFailed

mapBuffer :: BufferTarget -> BufferAccess -> IO (Maybe (Ptr a))
mapBuffer :: forall a. BufferTarget -> BufferAccess -> IO (Maybe (Ptr a))
mapBuffer BufferTarget
t = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b a. b -> (Ptr a -> b) -> Ptr a -> b
maybeNullPtr forall a. Maybe a
Nothing forall a. a -> Maybe a
Just) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. BufferTarget -> BufferAccess -> IO (Ptr a)
mapBuffer_ BufferTarget
t

mapBuffer_ :: BufferTarget -> BufferAccess -> IO (Ptr a)
mapBuffer_ :: forall a. BufferTarget -> BufferAccess -> IO (Ptr a)
mapBuffer_ BufferTarget
t = forall (m :: * -> *) a. MonadIO m => GLuint -> GLuint -> m (Ptr a)
glMapBuffer (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t) forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferAccess -> GLuint
marshalBufferAccess

unmapBuffer :: BufferTarget -> IO Bool
unmapBuffer :: BufferTarget -> IO Bool
unmapBuffer = forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. (Eq a, Num a) => a -> Bool
unmarshalGLboolean forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (m :: * -> *). MonadIO m => GLuint -> m GLboolean
glUnmapBuffer forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferTarget -> GLuint
marshalBufferTarget

bufferAccess :: BufferTarget -> GettableStateVar BufferAccess
bufferAccess :: BufferTarget -> GettableStateVar BufferAccess
bufferAccess BufferTarget
t = forall a. IO a -> IO a
makeGettableStateVar forall a b. (a -> b) -> a -> b
$
   forall a. BufferTarget -> (GLuint -> a) -> GetBufferPName -> IO a
getBufferParameter BufferTarget
t GLuint -> BufferAccess
unmarshalBufferAccess GetBufferPName
GetBufferAccess

bufferMapped :: BufferTarget -> GettableStateVar Bool
bufferMapped :: BufferTarget -> IO Bool
bufferMapped BufferTarget
t = forall a. IO a -> IO a
makeGettableStateVar forall a b. (a -> b) -> a -> b
$
   forall a. BufferTarget -> (GLuint -> a) -> GetBufferPName -> IO a
getBufferParameter BufferTarget
t forall a. (Eq a, Num a) => a -> Bool
unmarshalGLboolean GetBufferPName
GetBufferMapped

--------------------------------------------------------------------------------

data MapBufferUsage =
     Read
   | Write
   | InvalidateRange
   | InvalidateBuffer
   | FlushExplicit
   | Unsychronized
   deriving ( MapBufferUsage -> MapBufferUsage -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: MapBufferUsage -> MapBufferUsage -> Bool
$c/= :: MapBufferUsage -> MapBufferUsage -> Bool
== :: MapBufferUsage -> MapBufferUsage -> Bool
$c== :: MapBufferUsage -> MapBufferUsage -> Bool
Eq, Eq MapBufferUsage
MapBufferUsage -> MapBufferUsage -> Bool
MapBufferUsage -> MapBufferUsage -> Ordering
MapBufferUsage -> MapBufferUsage -> MapBufferUsage
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: MapBufferUsage -> MapBufferUsage -> MapBufferUsage
$cmin :: MapBufferUsage -> MapBufferUsage -> MapBufferUsage
max :: MapBufferUsage -> MapBufferUsage -> MapBufferUsage
$cmax :: MapBufferUsage -> MapBufferUsage -> MapBufferUsage
>= :: MapBufferUsage -> MapBufferUsage -> Bool
$c>= :: MapBufferUsage -> MapBufferUsage -> Bool
> :: MapBufferUsage -> MapBufferUsage -> Bool
$c> :: MapBufferUsage -> MapBufferUsage -> Bool
<= :: MapBufferUsage -> MapBufferUsage -> Bool
$c<= :: MapBufferUsage -> MapBufferUsage -> Bool
< :: MapBufferUsage -> MapBufferUsage -> Bool
$c< :: MapBufferUsage -> MapBufferUsage -> Bool
compare :: MapBufferUsage -> MapBufferUsage -> Ordering
$ccompare :: MapBufferUsage -> MapBufferUsage -> Ordering
Ord, Int -> MapBufferUsage -> ShowS
[MapBufferUsage] -> ShowS
MapBufferUsage -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MapBufferUsage] -> ShowS
$cshowList :: [MapBufferUsage] -> ShowS
show :: MapBufferUsage -> String
$cshow :: MapBufferUsage -> String
showsPrec :: Int -> MapBufferUsage -> ShowS
$cshowsPrec :: Int -> MapBufferUsage -> ShowS
Show )

type Offset = GLintptr
type Length = GLsizeiptr

marshalMapBufferUsage :: MapBufferUsage -> GLbitfield
marshalMapBufferUsage :: MapBufferUsage -> GLuint
marshalMapBufferUsage MapBufferUsage
x = case MapBufferUsage
x of
    MapBufferUsage
Read -> GLuint
GL_MAP_READ_BIT
    MapBufferUsage
Write -> GLuint
GL_MAP_WRITE_BIT
    MapBufferUsage
InvalidateRange -> GLuint
GL_MAP_INVALIDATE_RANGE_BIT
    MapBufferUsage
InvalidateBuffer -> GLuint
GL_MAP_INVALIDATE_BUFFER_BIT
    MapBufferUsage
FlushExplicit -> GLuint
GL_MAP_FLUSH_EXPLICIT_BIT
    MapBufferUsage
Unsychronized -> GLuint
GL_MAP_FLUSH_EXPLICIT_BIT

--------------------------------------------------------------------------------

mapBufferRange_ ::
   BufferTarget -> Offset -> Length -> [MapBufferUsage] -> IO (Ptr a)
mapBufferRange_ :: forall a.
BufferTarget
-> RangeStartIndex
-> RangeStartIndex
-> [MapBufferUsage]
-> IO (Ptr a)
mapBufferRange_ BufferTarget
t RangeStartIndex
o RangeStartIndex
l [MapBufferUsage]
b = forall (m :: * -> *) a.
MonadIO m =>
GLuint -> RangeStartIndex -> RangeStartIndex -> GLuint -> m (Ptr a)
glMapBufferRange (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t) RangeStartIndex
o RangeStartIndex
l
   (forall (t :: * -> *) a. (Foldable t, Num a) => t a -> a
sum (forall a b. (a -> b) -> [a] -> [b]
map MapBufferUsage -> GLuint
marshalMapBufferUsage [MapBufferUsage]
b))

mapBufferRange ::
   BufferTarget -> Offset -> Length -> [MapBufferUsage] -> IO (Maybe (Ptr a))
mapBufferRange :: forall a.
BufferTarget
-> RangeStartIndex
-> RangeStartIndex
-> [MapBufferUsage]
-> IO (Maybe (Ptr a))
mapBufferRange BufferTarget
t RangeStartIndex
o RangeStartIndex
l [MapBufferUsage]
b =
   forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall b a. b -> (Ptr a -> b) -> Ptr a -> b
maybeNullPtr forall a. Maybe a
Nothing forall a. a -> Maybe a
Just) forall a b. (a -> b) -> a -> b
$ forall a.
BufferTarget
-> RangeStartIndex
-> RangeStartIndex
-> [MapBufferUsage]
-> IO (Ptr a)
mapBufferRange_ BufferTarget
t RangeStartIndex
o RangeStartIndex
l [MapBufferUsage]
b

flushMappedBufferRange :: BufferTarget -> Offset -> Length -> IO ()
flushMappedBufferRange :: BufferTarget -> RangeStartIndex -> RangeStartIndex -> IO ()
flushMappedBufferRange BufferTarget
t = forall (m :: * -> *).
MonadIO m =>
GLuint -> RangeStartIndex -> RangeStartIndex -> m ()
glFlushMappedBufferRange (BufferTarget -> GLuint
marshalBufferTarget BufferTarget
t)

--------------------------------------------------------------------------------

type BufferIndex = GLuint

type RangeStartIndex = GLintptr
type RangeSize = GLsizeiptr
type BufferRange = (BufferObject, RangeStartIndex, RangeSize)

data IndexedBufferTarget =
     IndexedAtomicCounterBuffer
   | IndexedShaderStorageBuffer
   | IndexedTransformFeedbackBuffer
   | IndexedUniformBuffer
   deriving ( IndexedBufferTarget -> IndexedBufferTarget -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
$c/= :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
== :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
$c== :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
Eq, Eq IndexedBufferTarget
IndexedBufferTarget -> IndexedBufferTarget -> Bool
IndexedBufferTarget -> IndexedBufferTarget -> Ordering
IndexedBufferTarget -> IndexedBufferTarget -> IndexedBufferTarget
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: IndexedBufferTarget -> IndexedBufferTarget -> IndexedBufferTarget
$cmin :: IndexedBufferTarget -> IndexedBufferTarget -> IndexedBufferTarget
max :: IndexedBufferTarget -> IndexedBufferTarget -> IndexedBufferTarget
$cmax :: IndexedBufferTarget -> IndexedBufferTarget -> IndexedBufferTarget
>= :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
$c>= :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
> :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
$c> :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
<= :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
$c<= :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
< :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
$c< :: IndexedBufferTarget -> IndexedBufferTarget -> Bool
compare :: IndexedBufferTarget -> IndexedBufferTarget -> Ordering
$ccompare :: IndexedBufferTarget -> IndexedBufferTarget -> Ordering
Ord, Int -> IndexedBufferTarget -> ShowS
[IndexedBufferTarget] -> ShowS
IndexedBufferTarget -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [IndexedBufferTarget] -> ShowS
$cshowList :: [IndexedBufferTarget] -> ShowS
show :: IndexedBufferTarget -> String
$cshow :: IndexedBufferTarget -> String
showsPrec :: Int -> IndexedBufferTarget -> ShowS
$cshowsPrec :: Int -> IndexedBufferTarget -> ShowS
Show )

marshalIndexedBufferTarget :: IndexedBufferTarget -> IPName1I
marshalIndexedBufferTarget :: IndexedBufferTarget -> IPName1I
marshalIndexedBufferTarget IndexedBufferTarget
x = case IndexedBufferTarget
x of
   IndexedBufferTarget
IndexedAtomicCounterBuffer -> IPName1I
GetAtomicCounterBuffer
   IndexedBufferTarget
IndexedShaderStorageBuffer -> IPName1I
GetShaderStorageBuffer
   IndexedBufferTarget
IndexedTransformFeedbackBuffer -> IPName1I
GetTransformFeedbackBuffer
   IndexedBufferTarget
IndexedUniformBuffer -> IPName1I
GetUniformBuffer

bindBufferBase :: IndexedBufferTarget -> BufferIndex -> StateVar (Maybe BufferObject)
bindBufferBase :: IndexedBufferTarget -> GLuint -> StateVar (Maybe BufferObject)
bindBufferBase IndexedBufferTarget
t GLuint
i = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (IndexedBufferTarget -> GLuint -> IO (Maybe BufferObject)
getIndexedBufferBinding IndexedBufferTarget
t GLuint
i) (IndexedBufferTarget -> GLuint -> Maybe BufferObject -> IO ()
setIndexedBufferBase IndexedBufferTarget
t GLuint
i)

getIndexedBufferBinding :: IndexedBufferTarget -> BufferIndex -> IO (Maybe BufferObject)
getIndexedBufferBinding :: IndexedBufferTarget -> GLuint -> IO (Maybe BufferObject)
getIndexedBufferBinding IndexedBufferTarget
t GLuint
i = do
   BufferObject
buf <- forall p a. GetIPName1I p => (GLint -> a) -> p -> GLuint -> IO a
getInteger1i (GLuint -> BufferObject
BufferObject forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) (IndexedBufferTarget -> IPName1I
marshalIndexedBufferTarget IndexedBufferTarget
t) GLuint
i
   forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ if BufferObject
buf forall a. Eq a => a -> a -> Bool
== BufferObject
noBufferObject then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just BufferObject
buf

setIndexedBufferBase :: IndexedBufferTarget -> BufferIndex -> Maybe BufferObject -> IO ()
setIndexedBufferBase :: IndexedBufferTarget -> GLuint -> Maybe BufferObject -> IO ()
setIndexedBufferBase IndexedBufferTarget
t GLuint
i Maybe BufferObject
buf =
   case forall p. GetPName p => p -> Maybe GLuint
marshalGetPName forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndexedBufferTarget -> IPName1I
marshalIndexedBufferTarget forall a b. (a -> b) -> a -> b
$ IndexedBufferTarget
t of
      Maybe GLuint
Nothing -> IO ()
recordInvalidEnum
      Just GLuint
t' -> forall (m :: * -> *).
MonadIO m =>
GLuint -> GLuint -> GLuint -> m ()
glBindBufferBase GLuint
t' GLuint
i forall b c a. (b -> c) -> (a -> b) -> a -> c
. BufferObject -> GLuint
bufferID forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a -> a
fromMaybe BufferObject
noBufferObject forall a b. (a -> b) -> a -> b
$ Maybe BufferObject
buf

bindBufferRange :: IndexedBufferTarget -> BufferIndex -> StateVar (Maybe BufferRange)
bindBufferRange :: IndexedBufferTarget -> GLuint -> StateVar (Maybe BufferRange)
bindBufferRange IndexedBufferTarget
t GLuint
i = forall a. IO a -> (a -> IO ()) -> StateVar a
makeStateVar (IndexedBufferTarget -> GLuint -> IO (Maybe BufferRange)
getIndexedBufferRange IndexedBufferTarget
t GLuint
i) (IndexedBufferTarget -> GLuint -> Maybe BufferRange -> IO ()
setIndexedBufferRange IndexedBufferTarget
t GLuint
i)

getIndexedBufferRange :: IndexedBufferTarget -> BufferIndex -> IO (Maybe BufferRange)
getIndexedBufferRange :: IndexedBufferTarget -> GLuint -> IO (Maybe BufferRange)
getIndexedBufferRange IndexedBufferTarget
t GLuint
i = do
  BufferObject
buf <- forall p a. GetIPName1I p => (GLint -> a) -> p -> GLuint -> IO a
getInteger1i (GLuint -> BufferObject
BufferObject forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (Integral a, Num b) => a -> b
fromIntegral) (IndexedBufferTarget -> IPName1I
marshalIndexedBufferTarget IndexedBufferTarget
t) GLuint
i
  if BufferObject
buf forall a. Eq a => a -> a -> Bool
== BufferObject
noBufferObject
     then forall (m :: * -> *) a. Monad m => a -> m a
return forall a. Maybe a
Nothing
     else do RangeStartIndex
start <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get forall a b. (a -> b) -> a -> b
$ IndexedBufferTarget -> GLuint -> GettableStateVar RangeStartIndex
indexedBufferStart IndexedBufferTarget
t GLuint
i
             RangeStartIndex
size <- forall t a (m :: * -> *). (HasGetter t a, MonadIO m) => t -> m a
get forall a b. (a -> b) -> a -> b
$ IndexedBufferTarget -> GLuint -> GettableStateVar RangeStartIndex
indexedBufferSize IndexedBufferTarget
t GLuint
i
             forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just (BufferObject
buf, RangeStartIndex
start, RangeStartIndex
size)

setIndexedBufferRange :: IndexedBufferTarget -> BufferIndex -> Maybe BufferRange -> IO ()
setIndexedBufferRange :: IndexedBufferTarget -> GLuint -> Maybe BufferRange -> IO ()
setIndexedBufferRange IndexedBufferTarget
t GLuint
i Maybe BufferRange
br =
   case forall p. GetPName p => p -> Maybe GLuint
marshalGetPName forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndexedBufferTarget -> IPName1I
marshalIndexedBufferTarget forall a b. (a -> b) -> a -> b
$ IndexedBufferTarget
t of
      Maybe GLuint
Nothing -> IO ()
recordInvalidEnum
      Just GLuint
t' -> forall (m :: * -> *).
MonadIO m =>
GLuint
-> GLuint -> GLuint -> RangeStartIndex -> RangeStartIndex -> m ()
glBindBufferRange GLuint
t' GLuint
i (BufferObject -> GLuint
bufferID BufferObject
buf) RangeStartIndex
start RangeStartIndex
range
   where (BufferObject
buf, RangeStartIndex
start, RangeStartIndex
range) = forall a. a -> Maybe a -> a
fromMaybe (BufferObject
noBufferObject, RangeStartIndex
0, RangeStartIndex
0) Maybe BufferRange
br

getIndexed :: Num a => IPName1I -> BufferIndex -> GettableStateVar a
getIndexed :: forall a. Num a => IPName1I -> GLuint -> GettableStateVar a
getIndexed IPName1I
e GLuint
i = forall a. IO a -> IO a
makeGettableStateVar forall a b. (a -> b) -> a -> b
$ forall p a. GetIPName1I p => (GLint64 -> a) -> p -> GLuint -> IO a
getInteger641i forall a b. (Integral a, Num b) => a -> b
fromIntegral IPName1I
e GLuint
i

marshalIndexedBufferStart :: IndexedBufferTarget -> IPName1I
marshalIndexedBufferStart :: IndexedBufferTarget -> IPName1I
marshalIndexedBufferStart IndexedBufferTarget
x = case IndexedBufferTarget
x of
   IndexedBufferTarget
IndexedAtomicCounterBuffer -> IPName1I
GetAtomicCounterBufferStart
   IndexedBufferTarget
IndexedShaderStorageBuffer -> IPName1I
GetShaderStorageBufferStart
   IndexedBufferTarget
IndexedTransformFeedbackBuffer -> IPName1I
GetTransformFeedbackBufferStart
   IndexedBufferTarget
IndexedUniformBuffer -> IPName1I
GetUniformBufferStart

indexedBufferStart :: IndexedBufferTarget -> BufferIndex -> GettableStateVar RangeStartIndex
indexedBufferStart :: IndexedBufferTarget -> GLuint -> GettableStateVar RangeStartIndex
indexedBufferStart = forall a. Num a => IPName1I -> GLuint -> GettableStateVar a
getIndexed forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndexedBufferTarget -> IPName1I
marshalIndexedBufferStart

marshalIndexedBufferSize :: IndexedBufferTarget -> IPName1I
marshalIndexedBufferSize :: IndexedBufferTarget -> IPName1I
marshalIndexedBufferSize IndexedBufferTarget
x = case IndexedBufferTarget
x of
   IndexedBufferTarget
IndexedAtomicCounterBuffer -> IPName1I
GetAtomicCounterBufferSize
   IndexedBufferTarget
IndexedShaderStorageBuffer -> IPName1I
GetShaderStorageBufferSize
   IndexedBufferTarget
IndexedTransformFeedbackBuffer -> IPName1I
GetTransformFeedbackBufferSize
   IndexedBufferTarget
IndexedUniformBuffer -> IPName1I
GetUniformBufferSize

indexedBufferSize :: IndexedBufferTarget -> BufferIndex -> GettableStateVar RangeSize
indexedBufferSize :: IndexedBufferTarget -> GLuint -> GettableStateVar RangeStartIndex
indexedBufferSize = forall a. Num a => IPName1I -> GLuint -> GettableStateVar a
getIndexed forall b c a. (b -> c) -> (a -> b) -> a -> c
. IndexedBufferTarget -> IPName1I
marshalIndexedBufferSize