Raylib

Documentation

type LoadFileDataCallback = FunPtr (CString -> Ptr CUInt -> IO (Ptr CUChar))

mk'loadFileDataCallback :: (CString -> Ptr CUInt -> IO (Ptr CUChar)) -> IO LoadFileDataCallback

mK'loadFileDataCallback :: LoadFileDataCallback -> CString -> Ptr CUInt -> IO (Ptr CUChar)

type SaveFileDataCallback = FunPtr (CString -> Ptr () -> CUInt -> IO CInt)

mk'saveFileDataCallback :: (CString -> Ptr () -> CUInt -> IO CInt) -> IO SaveFileDataCallback

mK'saveFileDataCallback :: SaveFileDataCallback -> CString -> Ptr () -> CUInt -> IO CInt

type LoadFileTextCallback = FunPtr (CString -> IO CString)

mk'loadFileTextCallback :: (CString -> IO CString) -> IO LoadFileTextCallback

mK'loadFileTextCallback :: LoadFileTextCallback -> CString -> IO CString

type SaveFileTextCallback = FunPtr (CString -> CString -> IO CInt)

mk'saveFileTextCallback :: (CString -> CString -> IO CInt) -> IO SaveFileTextCallback

mK'saveFileTextCallback :: SaveFileTextCallback -> CString -> CString -> IO CInt

c'initWindow :: CInt -> CInt -> CString -> IO ()

initWindow :: Int -> Int -> String -> IO ()

p'initWindow :: FunPtr (CInt -> CInt -> CString -> IO ())

c'windowShouldClose :: IO CInt

windowShouldClose :: IO Bool

p'windowShouldClose :: FunPtr (IO CInt)

closeWindow :: IO ()

p'closeWindow :: FunPtr (IO ())

c'isWindowReady :: IO CInt

isWindowReady :: IO Bool

p'isWindowReady :: FunPtr (IO CInt)

c'isWindowFullscreen :: IO CInt

isWindowFullscreen :: IO Bool

p'isWindowFullscreen :: FunPtr (IO CInt)

c'isWindowHidden :: IO CInt

isWindowHidden :: IO Bool

p'isWindowHidden :: FunPtr (IO CInt)

c'isWindowMinimized :: IO CInt

isWindowMinimized :: IO Bool

p'isWindowMinimized :: FunPtr (IO CInt)

c'isWindowMaximized :: IO CInt

isWindowMaximized :: IO Bool

p'isWindowMaximized :: FunPtr (IO CInt)

c'isWindowFocused :: IO CInt

isWindowFocused :: IO Bool

p'isWindowFocused :: FunPtr (IO CInt)

c'isWindowResized :: IO CInt

isWindowResized :: IO Bool

p'isWindowResized :: FunPtr (IO CInt)

c'isWindowState :: CUInt -> IO CInt

isWindowState :: Integer -> IO Bool

p'isWindowState :: FunPtr (CUInt -> IO CInt)

c'setWindowState :: CUInt -> IO ()

setWindowState :: Integer -> IO ()

p'setWindowState :: FunPtr (CUInt -> IO ())

c'clearWindowState :: CUInt -> IO ()

clearWindowState :: Integer -> IO ()

p'clearWindowState :: FunPtr (CUInt -> IO ())

toggleFullscreen :: IO ()

p'toggleFullscreen :: FunPtr (IO ())

maximizeWindow :: IO ()

p'maximizeWindow :: FunPtr (IO ())

minimizeWindow :: IO ()

p'minimizeWindow :: FunPtr (IO ())

restoreWindow :: IO ()

p'restoreWindow :: FunPtr (IO ())

c'setWindowIcon :: Ptr Image -> IO ()

setWindowIcon :: Image -> IO ()

p'setWindowIcon :: FunPtr (Image -> IO ())

c'setWindowTitle :: CString -> IO ()

setWindowTitle :: String -> IO ()

p'setWindowTitle :: FunPtr (CString -> IO ())

c'setWindowPosition :: CInt -> CInt -> IO ()

setWindowPosition :: Int -> Int -> IO ()

p'setWindowPosition :: FunPtr (CInt -> CInt -> IO ())

c'setWindowMonitor :: CInt -> IO ()

setWindowMonitor :: Int -> IO ()

p'setWindowMonitor :: FunPtr (CInt -> IO ())

c'setWindowMinSize :: CInt -> CInt -> IO ()

setWindowMinSize :: Int -> Int -> IO ()

p'setWindowMinSize :: FunPtr (CInt -> CInt -> IO ())

c'setWindowSize :: CInt -> CInt -> IO ()

setWindowSize :: Int -> Int -> IO ()

p'setWindowSize :: FunPtr (CInt -> CInt -> IO ())

c'setWindowOpacity :: CFloat -> IO ()

setWindowOpacity :: Float -> IO ()

p'setWindowOpacity :: FunPtr (CFloat -> IO ())

getWindowHandle :: IO (Ptr ())

p'getWindowHandle :: FunPtr (IO (Ptr ()))

c'getScreenWidth :: IO CInt

getScreenWidth :: IO Int

p'getScreenWidth :: FunPtr (IO CInt)

c'getScreenHeight :: IO CInt

getScreenHeight :: IO Int

p'getScreenHeight :: FunPtr (IO CInt)

c'getRenderWidth :: IO CInt

getRenderWidth :: IO Int

p'getRenderWidth :: FunPtr (IO CInt)

c'getRenderHeight :: IO CInt

getRenderHeight :: IO Int

p'getRenderHeight :: FunPtr (IO CInt)

c'getMonitorCount :: IO CInt

getMonitorCount :: IO Int

p'getMonitorCount :: FunPtr (IO CInt)

c'getCurrentMonitor :: IO CInt

getCurrentMonitor :: IO Int

p'getCurrentMonitor :: FunPtr (IO CInt)

c'getMonitorPosition :: CInt -> IO (Ptr Vector2)

getMonitorPosition :: Int -> IO Vector2

p'getMonitorPosition :: FunPtr (CInt -> IO Vector2)

c'getMonitorWidth :: CInt -> IO CInt

getMonitorWidth :: Int -> IO Int

p'getMonitorWidth :: FunPtr (CInt -> IO CInt)

c'getMonitorHeight :: CInt -> IO CInt

getMonitorHeight :: Int -> IO CInt

p'getMonitorHeight :: FunPtr (CInt -> IO CInt)

c'getMonitorPhysicalWidth :: CInt -> IO CInt

getMonitorPhysicalWidth :: Int -> IO CInt

p'getMonitorPhysicalWidth :: FunPtr (CInt -> IO CInt)

c'getMonitorPhysicalHeight :: CInt -> IO CInt

getMonitorPhysicalHeight :: Int -> IO Int

p'getMonitorPhysicalHeight :: FunPtr (CInt -> IO CInt)

c'getMonitorRefreshRate :: CInt -> IO CInt

getMonitorRefreshRate :: Int -> IO Int

p'getMonitorRefreshRate :: FunPtr (CInt -> IO CInt)

c'getWindowPosition :: IO (Ptr Vector2)

getWindowPosition :: IO Vector2

p'getWindowPosition :: FunPtr (IO Vector2)

c'getWindowScaleDPI :: IO (Ptr Vector2)

getWindowScaleDPI :: IO Vector2

p'getWindowScaleDPI :: FunPtr (IO Vector2)

c'getMonitorName :: CInt -> IO CString

getMonitorName :: Int -> IO String

p'getMonitorName :: FunPtr (CInt -> IO CString)

c'setClipboardText :: CString -> IO ()

setClipboardText :: String -> IO ()

p'setClipboardText :: FunPtr (CString -> IO ())

c'getClipboardText :: IO CString

getClipboardText :: IO String

p'getClipboardText :: FunPtr (IO CString)

enableEventWaiting :: IO ()

p'enableEventWaiting :: FunPtr (IO ())

disableEventWaiting :: IO ()

p'disableEventWaiting :: FunPtr (IO ())

swapScreenBuffer :: IO ()

p'swapScreenBuffer :: FunPtr (IO ())

pollInputEvents :: IO ()

p'pollInputEvents :: FunPtr (IO ())

c'waitTime :: CDouble -> IO ()

waitTime :: Double -> IO ()

p'waitTime :: FunPtr (CDouble -> IO ())

showCursor :: IO ()

p'showCursor :: FunPtr (IO ())

hideCursor :: IO ()

p'hideCursor :: FunPtr (IO ())

c'isCursorHidden :: IO CInt

isCursorHidden :: IO Bool

p'isCursorHidden :: FunPtr (IO CInt)

enableCursor :: IO ()

p'enableCursor :: FunPtr (IO ())

disableCursor :: IO ()

p'disableCursor :: FunPtr (IO ())

c'isCursorOnScreen :: IO CInt

isCursorOnScreen :: IO Bool

p'isCursorOnScreen :: FunPtr (IO CInt)

c'clearBackground :: Ptr Color -> IO ()

clearBackground :: Color -> IO ()

p'clearBackground :: FunPtr (Color -> IO ())

beginDrawing :: IO ()

p'beginDrawing :: FunPtr (IO ())

endDrawing :: IO ()

p'endDrawing :: FunPtr (IO ())

c'beginMode2D :: Ptr Camera2D -> IO ()

beginMode2D :: Camera2D -> IO ()

p'beginMode2D :: FunPtr (Camera2D -> IO ())

endMode2D :: IO ()

p'endMode2D :: FunPtr (IO ())

c'beginMode3D :: Ptr Camera3D -> IO ()

beginMode3D :: Camera3D -> IO ()

p'beginMode3D :: FunPtr (Camera3D -> IO ())

endMode3D :: IO ()

p'endMode3D :: FunPtr (IO ())

c'beginTextureMode :: Ptr RenderTexture -> IO ()

beginTextureMode :: RenderTexture -> IO ()

p'beginTextureMode :: FunPtr (RenderTexture -> IO ())

endTextureMode :: IO ()

p'endTextureMode :: FunPtr (IO ())

c'beginShaderMode :: Ptr Shader -> IO ()

beginShaderMode :: Shader -> IO ()

p'beginShaderMode :: FunPtr (Shader -> IO ())

endShaderMode :: IO ()

p'endShaderMode :: FunPtr (IO ())

c'beginBlendMode :: CInt -> IO ()

beginBlendMode :: Int -> IO ()

p'beginBlendMode :: FunPtr (CInt -> IO ())

endBlendMode :: IO ()

p'endBlendMode :: FunPtr (IO ())

c'beginScissorMode :: CInt -> CInt -> CInt -> CInt -> IO ()

beginScissorMode :: Int -> Int -> Int -> Int -> IO ()

p'beginScissorMode :: FunPtr (CInt -> CInt -> CInt -> CInt -> IO ())

endScissorMode :: IO ()

p'endScissorMode :: FunPtr (IO ())

c'beginVrStereoMode :: Ptr VrStereoConfig -> IO ()

beginVrStereoMode :: VrStereoConfig -> IO ()

p'beginVrStereoMode :: FunPtr (VrStereoConfig -> IO ())

endVrStereoMode :: IO ()

p'endVrStereoMode :: FunPtr (IO ())

c'loadVrStereoConfig :: Ptr VrDeviceInfo -> IO (Ptr VrStereoConfig)

loadVrStereoConfig :: VrDeviceInfo -> IO VrStereoConfig

p'loadVrStereoConfig :: FunPtr (VrDeviceInfo -> IO VrStereoConfig)

c'unloadVrStereoConfig :: Ptr VrStereoConfig -> IO ()

unloadVrStereoConfig :: VrStereoConfig -> IO ()

p'unloadVrStereoConfig :: FunPtr (VrStereoConfig -> IO ())

c'loadShader :: CString -> CString -> IO (Ptr Shader)

loadShader :: String -> String -> IO Shader

p'loadShader :: FunPtr (CString -> CString -> IO Shader)

c'loadShaderFromMemory :: CString -> CString -> IO (Ptr Shader)

loadShaderFromMemory :: String -> String -> IO Shader

p'loadShaderFromMemory :: FunPtr (CString -> CString -> IO Shader)

c'getShaderLocation :: Ptr Shader -> CString -> IO CInt

getShaderLocation :: Shader -> String -> IO Int

p'getShaderLocation :: FunPtr (Shader -> CString -> IO CInt)

c'getShaderLocationAttrib :: Ptr Shader -> CString -> IO CInt

getShaderLocationAttrib :: Shader -> String -> IO Int

p'getShaderLocationAttrib :: FunPtr (Shader -> CString -> IO CInt)

c'setShaderValue :: Ptr Shader -> CInt -> Ptr () -> CInt -> IO ()

setShaderValue :: Shader -> Int -> Ptr () -> Int -> IO ()

p'setShaderValue :: FunPtr (Shader -> CInt -> Ptr () -> CInt -> IO ())

c'setShaderValueV :: Ptr Shader -> CInt -> Ptr () -> CInt -> CInt -> IO ()

setShaderValueV :: Shader -> Int -> Ptr () -> Int -> Int -> IO ()

p'setShaderValueV :: FunPtr (Shader -> CInt -> Ptr () -> CInt -> CInt -> IO ())

c'setShaderValueMatrix :: Ptr Shader -> CInt -> Ptr Matrix -> IO ()

setShaderValueMatrix :: Shader -> Int -> Matrix -> IO ()

p'setShaderValueMatrix :: FunPtr (Shader -> CInt -> Matrix -> IO ())

c'setShaderValueTexture :: Ptr Shader -> CInt -> Ptr Texture -> IO ()

setShaderValueTexture :: Shader -> Int -> Texture -> IO ()

p'setShaderValueTexture :: FunPtr (Shader -> CInt -> Texture -> IO ())

c'unloadShader :: Ptr Shader -> IO ()

unloadShader :: Shader -> IO ()

p'unloadShader :: FunPtr (Shader -> IO ())

c'getMouseRay :: Ptr Vector2 -> Ptr Camera3D -> IO (Ptr Ray)

getMouseRay :: Vector2 -> Camera3D -> IO Ray

p'getMouseRay :: FunPtr (Vector2 -> Camera3D -> IO Ray)

c'getCameraMatrix :: Ptr Camera3D -> IO (Ptr Matrix)

getCameraMatrix :: Camera3D -> IO Matrix

p'getCameraMatrix :: FunPtr (Camera3D -> IO Matrix)

c'getCameraMatrix2D :: Ptr Camera2D -> IO (Ptr Matrix)

getCameraMatrix2D :: Camera2D -> IO Matrix

p'getCameraMatrix2D :: FunPtr (Camera2D -> IO Matrix)

c'getWorldToScreen :: Ptr Vector3 -> Ptr Camera3D -> IO (Ptr Vector2)

getWorldToScreen :: Vector3 -> Camera3D -> IO Vector2

p'getWorldToScreen :: FunPtr (Vector3 -> Camera3D -> IO Vector2)

c'getScreenToWorld2D :: Ptr Vector2 -> Ptr Camera2D -> IO (Ptr Vector2)

getScreenToWorld2D :: Vector2 -> Camera2D -> IO Vector2

p'getScreenToWorld2D :: FunPtr (Vector2 -> Camera2D -> IO Vector2)

c'getWorldToScreenEx :: Ptr Vector3 -> Ptr Camera3D -> CInt -> CInt -> IO (Ptr Vector2)

getWorldToScreenEx :: Vector3 -> Camera3D -> Int -> Int -> IO Vector2

p'getWorldToScreenEx :: FunPtr (Vector3 -> Camera3D -> CInt -> CInt -> IO Vector2)

c'getWorldToScreen2D :: Ptr Vector2 -> Ptr Camera2D -> IO (Ptr Vector2)

getWorldToScreen2D :: Vector2 -> Camera2D -> IO Vector2

p'getWorldToScreen2D :: FunPtr (Vector2 -> Camera2D -> IO Vector2)

c'setTargetFPS :: CInt -> IO ()

setTargetFPS :: Int -> IO ()

p'setTargetFPS :: FunPtr (CInt -> IO ())

c'getFPS :: IO CInt

getFPS :: IO Int

p'getFPS :: FunPtr (IO CInt)

c'getFrameTime :: IO CFloat

getFrameTime :: IO Float

p'getFrameTime :: FunPtr (IO CFloat)

c'getTime :: IO CDouble

getTime :: IO Double

p'getTime :: FunPtr (IO CDouble)

c'getRandomValue :: CInt -> CInt -> IO CInt

getRandomValue :: Int -> Int -> IO Int

p'getRandomValue :: FunPtr (CInt -> CInt -> IO CInt)

c'setRandomSeed :: CUInt -> IO ()

setRandomSeed :: Integer -> IO ()

p'setRandomSeed :: FunPtr (CUInt -> IO ())

c'takeScreenshot :: CString -> IO ()

takeScreenshot :: String -> IO ()

p'takeScreenshot :: FunPtr (CString -> IO ())

c'setConfigFlags :: CUInt -> IO ()

setConfigFlags :: Integer -> IO ()

p'setConfigFlags :: FunPtr (CUInt -> IO ())

c'traceLog :: CInt -> CString -> IO ()

traceLog :: Int -> String -> IO ()

p'traceLog :: FunPtr (CInt -> CString -> IO ())

c'setTraceLogLevel :: CInt -> IO ()

setTraceLogLevel :: Int -> IO ()

p'setTraceLogLevel :: FunPtr (CInt -> IO ())

c'memAlloc :: CInt -> IO (Ptr ())

memAlloc :: Storable a => Int -> IO (Ptr a)

p'memAlloc :: FunPtr (CInt -> IO (Ptr ()))

c'memRealloc :: Ptr () -> CInt -> IO (Ptr ())

memRealloc :: (Storable a, Storable b) => Ptr a -> Int -> IO (Ptr b)

p'memRealloc :: FunPtr (Ptr () -> CInt -> IO (Ptr ()))

c'memFree :: Ptr () -> IO ()

memFree :: Storable a => Ptr a -> IO ()

p'memFree :: FunPtr (Ptr () -> IO ())

c'openURL :: CString -> IO ()

openURL :: String -> IO ()

p'openURL :: FunPtr (CString -> IO ())

setLoadFileDataCallback :: LoadFileDataCallback -> IO ()

p'setLoadFileDataCallback :: FunPtr (LoadFileDataCallback -> IO ())

setSaveFileDataCallback :: SaveFileDataCallback -> IO ()

p'setSaveFileDataCallback :: FunPtr (SaveFileDataCallback -> IO ())

setLoadFileTextCallback :: LoadFileTextCallback -> IO ()

p'setLoadFileTextCallback :: FunPtr (LoadFileTextCallback -> IO ())

setSaveFileTextCallback :: SaveFileTextCallback -> IO ()

p'setSaveFileTextCallback :: FunPtr (SaveFileTextCallback -> IO ())

c'loadFileData :: CString -> Ptr CUInt -> IO (Ptr CUChar)

loadFileData :: String -> IO [Integer]

p'loadFileData :: FunPtr (CString -> Ptr CUInt -> IO (Ptr CUChar))

c'unloadFileData :: Ptr CUChar -> IO ()

p'unloadFileData :: FunPtr (Ptr CUChar -> IO ())

c'saveFileData :: CString -> Ptr () -> CUInt -> IO CInt

saveFileData :: Storable a => String -> Ptr a -> Integer -> IO Bool

p'saveFileData :: FunPtr (CString -> Ptr () -> CUInt -> IO CInt)

c'exportDataAsCode :: CString -> CUInt -> CString -> IO CInt

exportDataAsCode :: String -> Integer -> String -> IO Bool

p'exportDataAsCode :: FunPtr (CString -> CUInt -> CString -> IO CInt)

c'loadFileText :: CString -> IO CString

loadFileText :: String -> IO String

p'loadFileText :: FunPtr (CString -> IO CString)

c'unloadFileText :: CString -> IO ()

unloadFileText :: String -> IO ()

p'unloadFileText :: FunPtr (CString -> IO ())

c'saveFileText :: CString -> CString -> IO CInt

saveFileText :: String -> String -> IO Bool

p'saveFileText :: FunPtr (CString -> CString -> IO CInt)

c'fileExists :: CString -> IO CInt

fileExists :: String -> IO Bool

p'fileExists :: FunPtr (CString -> IO CInt)

c'directoryExists :: CString -> IO CInt

directoryExists :: String -> IO Bool

p'directoryExists :: FunPtr (CString -> IO CInt)

c'isFileExtension :: CString -> CString -> IO CInt

isFileExtension :: String -> String -> IO Bool

p'isFileExtension :: FunPtr (CString -> CString -> IO CInt)

c'getFileLength :: CString -> IO CInt

getFileLength :: String -> IO Bool

p'getFileLength :: FunPtr (CString -> IO CInt)

c'getFileExtension :: CString -> IO CString

getFileExtension :: String -> IO String

p'getFileExtension :: FunPtr (CString -> IO CString)

c'getFileName :: CString -> IO CString

getFileName :: String -> IO String

p'getFileName :: FunPtr (CString -> IO CString)

c'getFileNameWithoutExt :: CString -> IO CString

getFileNameWithoutExt :: String -> IO String

p'getFileNameWithoutExt :: FunPtr (CString -> IO CString)

c'getDirectoryPath :: CString -> IO CString

getDirectoryPath :: String -> IO String

p'getDirectoryPath :: FunPtr (CString -> IO CString)

c'getPrevDirectoryPath :: CString -> IO CString

getPrevDirectoryPath :: String -> IO String

p'getPrevDirectoryPath :: FunPtr (CString -> IO CString)

c'getWorkingDirectory :: IO CString

getWorkingDirectory :: IO String

p'getWorkingDirectory :: FunPtr (IO CString)

c'getApplicationDirectory :: IO CString

getApplicationDirectory :: IO String

p'getApplicationDirectory :: FunPtr (IO CString)

c'changeDirectory :: CString -> IO CInt

changeDirectory :: String -> IO Bool

p'changeDirectory :: FunPtr (CString -> IO CInt)

c'isPathFile :: CString -> IO CInt

isPathFile :: String -> IO Bool

p'isPathFile :: FunPtr (CString -> IO CInt)

c'loadDirectoryFiles :: CString -> IO (Ptr FilePathList)

loadDirectoryFiles :: String -> IO FilePathList

p'loadDirectoryFiles :: FunPtr (CString -> IO FilePathList)

c'loadDirectoryFilesEx :: CString -> CString -> CInt -> IO (Ptr FilePathList)

loadDirectoryFilesEx :: String -> String -> Bool -> IO FilePathList

p'loadDirectoryFilesEx :: FunPtr (CString -> CString -> CInt -> IO FilePathList)

c'unloadDirectoryFiles :: Ptr FilePathList -> IO ()

unloadDirectoryFiles :: FilePathList -> IO ()

p'unloadDirectoryFiles :: FunPtr (FilePathList -> IO ())

c'isFileDropped :: IO CInt

isFileDropped :: IO Bool

p'isFileDropped :: FunPtr (IO CInt)

c'loadDroppedFiles :: IO (Ptr FilePathList)

loadDroppedFiles :: IO FilePathList

p'loadDroppedFiles :: FunPtr (IO FilePathList)

c'unloadDroppedFiles :: Ptr FilePathList -> IO ()

unloadDroppedFiles :: FilePathList -> IO ()

p'unloadDroppedFiles :: FunPtr (FilePathList -> IO ())

c'getFileModTime :: CString -> IO CLong

getFileModTime :: String -> IO Integer

p'getFileModTime :: FunPtr (CString -> IO CLong)

c'compressData :: Ptr CUChar -> CInt -> Ptr CInt -> IO (Ptr CUChar)

compressData :: [Integer] -> IO [Integer]

p'compressData :: FunPtr (Ptr CUChar -> CInt -> Ptr CInt -> IO (Ptr CUChar))

c'decompressData :: Ptr CUChar -> CInt -> Ptr CInt -> IO (Ptr CUChar)

decompressData :: [Integer] -> IO [Integer]

p'decompressData :: FunPtr (Ptr CUChar -> CInt -> Ptr CInt -> IO (Ptr CUChar))

c'encodeDataBase64 :: Ptr CUChar -> CInt -> Ptr CInt -> IO CString

encodeDataBase64 :: [Integer] -> IO [Integer]

p'encodeDataBase64 :: FunPtr (Ptr CUChar -> CInt -> Ptr CInt -> IO CString)

c'decodeDataBase64 :: Ptr CUChar -> Ptr CInt -> IO (Ptr CUChar)

decodeDataBase64 :: [Integer] -> IO [Integer]

p'decodeDataBase64 :: FunPtr (Ptr CUChar -> Ptr CInt -> IO (Ptr CUChar))

c'isKeyPressed :: CInt -> IO CInt

isKeyPressed :: Int -> IO Bool

p'isKeyPressed :: FunPtr (CInt -> IO CInt)

c'isKeyDown :: CInt -> IO CInt

isKeyDown :: Int -> IO Bool

p'isKeyDown :: FunPtr (CInt -> IO CInt)

c'isKeyReleased :: CInt -> IO CInt

isKeyReleased :: Int -> IO Bool

p'isKeyReleased :: FunPtr (CInt -> IO CInt)

c'isKeyUp :: CInt -> IO CInt

isKeyUp :: Int -> IO Bool

p'isKeyUp :: FunPtr (CInt -> IO CInt)

c'setExitKey :: CInt -> IO ()

setExitKey :: Int -> IO ()

p'setExitKey :: FunPtr (CInt -> IO ())

c'getKeyPressed :: IO CInt

getKeyPressed :: IO Int

p'getKeyPressed :: FunPtr (IO CInt)

c'getCharPressed :: IO CInt

getCharPressed :: IO Int

p'getCharPressed :: FunPtr (IO CInt)

c'isGamepadAvailable :: CInt -> IO CInt

isGamepadAvailable :: Int -> IO Bool

p'isGamepadAvailable :: FunPtr (CInt -> IO CInt)

c'getGamepadName :: CInt -> IO CString

getGamepadName :: Int -> IO String

p'getGamepadName :: FunPtr (CInt -> IO CString)

c'isGamepadButtonPressed :: CInt -> CInt -> IO CInt

isGamepadButtonPressed :: Int -> Int -> IO Bool

p'isGamepadButtonPressed :: FunPtr (CInt -> CInt -> IO CInt)

c'isGamepadButtonDown :: CInt -> CInt -> IO CInt

isGamepadButtonDown :: Int -> Int -> IO Bool

p'isGamepadButtonDown :: FunPtr (CInt -> CInt -> IO CInt)

c'isGamepadButtonReleased :: CInt -> CInt -> IO CInt

isGamepadButtonReleased :: Int -> Int -> IO Bool

p'isGamepadButtonReleased :: FunPtr (CInt -> CInt -> IO CInt)

c'isGamepadButtonUp :: CInt -> CInt -> IO CInt

isGamepadButtonUp :: Int -> Int -> IO Bool

p'isGamepadButtonUp :: FunPtr (CInt -> CInt -> IO CInt)

c'getGamepadButtonPressed :: IO CInt

getGamepadButtonPressed :: IO Int

p'getGamepadButtonPressed :: FunPtr (IO CInt)

c'getGamepadAxisCount :: CInt -> IO CInt

getGamepadAxisCount :: Int -> IO Int

p'getGamepadAxisCount :: FunPtr (CInt -> IO CInt)

c'getGamepadAxisMovement :: CInt -> CInt -> IO CFloat

getGamepadAxisMovement :: Int -> Int -> IO Float

p'getGamepadAxisMovement :: FunPtr (CInt -> CInt -> IO CFloat)

c'setGamepadMappings :: CString -> IO CInt

setGamepadMappings :: String -> IO Int

p'setGamepadMappings :: FunPtr (CString -> IO CInt)

c'isMouseButtonPressed :: CInt -> IO CInt

isMouseButtonPressed :: Int -> IO Bool

p'isMouseButtonPressed :: FunPtr (CInt -> IO CInt)

c'isMouseButtonDown :: CInt -> IO CInt

isMouseButtonDown :: Int -> IO Bool

p'isMouseButtonDown :: FunPtr (CInt -> IO CInt)

c'isMouseButtonReleased :: CInt -> IO CInt

isMouseButtonReleased :: Int -> IO Bool

p'isMouseButtonReleased :: FunPtr (CInt -> IO CInt)

c'isMouseButtonUp :: CInt -> IO CInt

isMouseButtonUp :: Int -> IO Bool

p'isMouseButtonUp :: FunPtr (CInt -> IO CInt)

c'getMouseX :: IO CInt

getMouseX :: IO Int

p'getMouseX :: FunPtr (IO CInt)

c'getMouseY :: IO CInt

getMouseY :: IO Int

p'getMouseY :: FunPtr (IO CInt)

c'getMousePosition :: IO (Ptr Vector2)

getMousePosition :: IO Vector2

p'getMousePosition :: FunPtr (IO Vector2)

c'getMouseDelta :: IO (Ptr Vector2)

getMouseDelta :: IO Vector2

p'getMouseDelta :: FunPtr (IO Vector2)

c'setMousePosition :: CInt -> CInt -> IO ()

setMousePosition :: Int -> Int -> IO ()

p'setMousePosition :: FunPtr (CInt -> CInt -> IO ())

c'setMouseOffset :: CInt -> CInt -> IO ()

setMouseOffset :: Int -> Int -> IO ()

p'setMouseOffset :: FunPtr (CInt -> CInt -> IO ())

c'setMouseScale :: CFloat -> CFloat -> IO ()

setMouseScale :: Float -> Float -> IO ()

p'setMouseScale :: FunPtr (CFloat -> CFloat -> IO ())

c'getMouseWheelMove :: IO CFloat

getMouseWheelMove :: IO Float

p'getMouseWheelMove :: FunPtr (IO CFloat)

c'getMouseWheelMoveV :: IO (Ptr Vector2)

getMouseWheelMoveV :: IO Vector2

p'getMouseWheelMoveV :: FunPtr (IO Vector2)

c'setMouseCursor :: CInt -> IO ()

setMouseCursor :: Int -> IO ()

p'setMouseCursor :: FunPtr (CInt -> IO ())

c'getTouchX :: IO CInt

getTouchX :: IO Int

p'getTouchX :: FunPtr (IO CInt)

c'getTouchY :: IO CInt

getTouchY :: IO Int

p'getTouchY :: FunPtr (IO CInt)

c'getTouchPosition :: CInt -> IO (Ptr Vector2)

getTouchPosition :: Int -> IO Vector2

p'getTouchPosition :: FunPtr (CInt -> IO Vector2)

c'getTouchPointId :: CInt -> IO CInt

getTouchPointId :: Int -> IO Int

p'getTouchPointId :: FunPtr (CInt -> IO CInt)

c'getTouchPointCount :: IO CInt

getTouchPointCount :: IO Int

p'getTouchPointCount :: FunPtr (IO CInt)

c'setGesturesEnabled :: CUInt -> IO ()

setGesturesEnabled :: Integer -> IO ()

p'setGesturesEnabled :: FunPtr (CUInt -> IO ())

c'isGestureDetected :: CInt -> IO CInt

isGestureDetected :: Int -> IO Bool

p'isGestureDetected :: FunPtr (CInt -> IO CInt)

c'getGestureDetected :: IO CInt

getGestureDetected :: IO Int

p'getGestureDetected :: FunPtr (IO CInt)

c'getGestureHoldDuration :: IO CFloat

getGestureHoldDuration :: IO Float

p'getGestureHoldDuration :: FunPtr (IO CFloat)

c'getGestureDragVector :: IO (Ptr Vector2)

getGestureDragVector :: IO Vector2

p'getGestureDragVector :: FunPtr (IO Vector2)

c'getGestureDragAngle :: IO CFloat

getGestureDragAngle :: IO Float

p'getGestureDragAngle :: FunPtr (IO CFloat)

c'getGesturePinchVector :: IO (Ptr Vector2)

getGesturePinchVector :: IO Vector2

p'getGesturePinchVector :: FunPtr (IO Vector2)

c'getGesturePinchAngle :: IO CFloat

getGesturePinchAngle :: IO Float

p'getGesturePinchAngle :: FunPtr (IO CFloat)

c'setCameraMode :: Ptr Camera3D -> CInt -> IO ()

setCameraMode :: Camera3D -> Int -> IO ()

p'setCameraMode :: FunPtr (Camera3D -> CInt -> IO ())

c'updateCamera :: Ptr Camera3D -> IO ()

updateCamera :: Camera3D -> IO Camera3D

p'updateCamera :: FunPtr (Ptr Camera3D -> IO ())

c'setCameraPanControl :: CInt -> IO ()

setCameraPanControl :: Int -> IO ()

p'setCameraPanControl :: FunPtr (CInt -> IO ())

c'setCameraAltControl :: CInt -> IO ()

setCameraAltControl :: Int -> IO ()

p'setCameraAltControl :: FunPtr (CInt -> IO ())

c'setCameraSmoothZoomControl :: CInt -> IO ()

setCameraSmoothZoomControl :: Int -> IO ()

p'setCameraSmoothZoomControl :: FunPtr (CInt -> IO ())

c'setCameraMoveControls :: CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ()

setCameraMoveControls :: Int -> Int -> Int -> Int -> Int -> Int -> IO ()

p'setCameraMoveControls :: FunPtr (CInt -> CInt -> CInt -> CInt -> CInt -> CInt -> IO ())

c'setShapesTexture :: Ptr Texture -> Ptr Rectangle -> IO ()

setShapesTexture :: Texture -> Rectangle -> IO ()

p'setShapesTexture :: FunPtr (Texture -> Rectangle -> IO ())

c'drawPixel :: CInt -> CInt -> Ptr Color -> IO ()

drawPixel :: Int -> Int -> Color -> IO ()

p'drawPixel :: FunPtr (CInt -> CInt -> Color -> IO ())

c'drawPixelV :: Ptr Vector2 -> Ptr Color -> IO ()

drawPixelV :: Vector2 -> Color -> IO ()

p'drawPixelV :: FunPtr (Vector2 -> Color -> IO ())

c'drawLine :: CInt -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

drawLine :: Int -> Int -> Int -> Int -> Color -> IO ()

p'drawLine :: FunPtr (CInt -> CInt -> CInt -> CInt -> Color -> IO ())

c'drawLineV :: Ptr Vector2 -> Ptr Vector2 -> Ptr Color -> IO ()

drawLineV :: Vector2 -> Vector2 -> Color -> IO ()

p'drawLineV :: FunPtr (Vector2 -> Vector2 -> Color -> IO ())

c'drawLineEx :: Ptr Vector2 -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawLineEx :: Vector2 -> Vector2 -> Float -> Color -> IO ()

p'drawLineEx :: FunPtr (Vector2 -> Vector2 -> CFloat -> Color -> IO ())

c'drawLineBezier :: Ptr Vector2 -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawLineBezier :: Vector2 -> Vector2 -> Float -> Color -> IO ()

p'drawLineBezier :: FunPtr (Vector2 -> Vector2 -> CFloat -> Color -> IO ())

c'drawLineBezierQuad :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawLineBezierQuad :: Vector2 -> Vector2 -> Vector2 -> Float -> Color -> IO ()

p'drawLineBezierQuad :: FunPtr (Vector2 -> Vector2 -> Vector2 -> CFloat -> Color -> IO ())

c'drawLineBezierCubic :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawLineBezierCubic :: Vector2 -> Vector2 -> Vector2 -> Vector2 -> Float -> Color -> IO ()

p'drawLineBezierCubic :: FunPtr (Vector2 -> Vector2 -> Vector2 -> Vector2 -> CFloat -> Color -> IO ())

c'drawLineStrip :: Ptr Vector2 -> CInt -> Ptr Color -> IO ()

drawLineStrip :: [Vector2] -> Color -> IO ()

p'drawLineStrip :: FunPtr (Ptr Vector2 -> CInt -> Color -> IO ())

c'drawCircle :: CInt -> CInt -> CFloat -> Ptr Color -> IO ()

drawCircle :: Int -> Int -> Float -> Color -> IO ()

p'drawCircle :: FunPtr (CInt -> CInt -> CFloat -> Color -> IO ())

c'drawCircleSector :: Ptr Vector2 -> CFloat -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawCircleSector :: Vector2 -> Float -> Float -> Float -> Int -> Color -> IO ()

p'drawCircleSector :: FunPtr (Vector2 -> CFloat -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawCircleSectorLines :: Ptr Vector2 -> CFloat -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawCircleSectorLines :: Vector2 -> Float -> Float -> Float -> Int -> Color -> IO ()

p'drawCircleSectorLines :: FunPtr (Vector2 -> CFloat -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawCircleGradient :: CInt -> CInt -> CFloat -> Ptr Color -> Ptr Color -> IO ()

drawCircleGradient :: Int -> Int -> Float -> Color -> Color -> IO ()

p'drawCircleGradient :: FunPtr (CInt -> CInt -> CFloat -> Color -> Color -> IO ())

c'drawCircleV :: Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawCircleV :: Vector2 -> Float -> Color -> IO ()

p'drawCircleV :: FunPtr (Vector2 -> CFloat -> Color -> IO ())

c'drawCircleLines :: CInt -> CInt -> CFloat -> Ptr Color -> IO ()

drawCircleLines :: Int -> Int -> Float -> Color -> IO ()

p'drawCircleLines :: FunPtr (CInt -> CInt -> CFloat -> Color -> IO ())

c'drawEllipse :: CInt -> CInt -> CFloat -> CFloat -> Ptr Color -> IO ()

drawEllipse :: Int -> Int -> Float -> Float -> Color -> IO ()

p'drawEllipse :: FunPtr (CInt -> CInt -> CFloat -> CFloat -> Color -> IO ())

c'drawEllipseLines :: CInt -> CInt -> CFloat -> CFloat -> Ptr Color -> IO ()

drawEllipseLines :: Int -> Int -> Float -> Float -> Color -> IO ()

p'drawEllipseLines :: FunPtr (CInt -> CInt -> CFloat -> CFloat -> Color -> IO ())

c'drawRing :: Ptr Vector2 -> CFloat -> CFloat -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawRing :: Vector2 -> Float -> Float -> Float -> Float -> Int -> Color -> IO ()

p'drawRing :: FunPtr (Vector2 -> CFloat -> CFloat -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawRingLines :: Ptr Vector2 -> CFloat -> CFloat -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawRingLines :: Vector2 -> Float -> Float -> Float -> Float -> Int -> Color -> IO ()

p'drawRingLines :: FunPtr (Vector2 -> CFloat -> CFloat -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawRectangle :: CInt -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

drawRectangle :: Int -> Int -> Int -> Int -> Color -> IO ()

p'drawRectangle :: FunPtr (CInt -> CInt -> CInt -> CInt -> Color -> IO ())

c'drawRectangleV :: Ptr Vector2 -> Ptr Vector2 -> Ptr Color -> IO ()

drawRectangleV :: Vector2 -> Vector2 -> Color -> IO ()

p'drawRectangleV :: FunPtr (Vector2 -> Vector2 -> Color -> IO ())

c'drawRectangleRec :: Ptr Rectangle -> Ptr Color -> IO ()

drawRectangleRec :: Rectangle -> Color -> IO ()

p'drawRectangleRec :: FunPtr (Rectangle -> Color -> IO ())

c'drawRectanglePro :: Ptr Rectangle -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawRectanglePro :: Rectangle -> Vector2 -> Float -> Color -> IO ()

p'drawRectanglePro :: FunPtr (Rectangle -> Vector2 -> CFloat -> Color -> IO ())

c'drawRectangleGradientV :: CInt -> CInt -> CInt -> CInt -> Ptr Color -> Ptr Color -> IO ()

drawRectangleGradientV :: Int -> Int -> Int -> Int -> Color -> Color -> IO ()

p'drawRectangleGradientV :: FunPtr (CInt -> CInt -> CInt -> CInt -> Color -> Color -> IO ())

c'drawRectangleGradientH :: CInt -> CInt -> CInt -> CInt -> Ptr Color -> Ptr Color -> IO ()

drawRectangleGradientH :: Int -> Int -> Int -> Int -> Color -> Color -> IO ()

p'drawRectangleGradientH :: FunPtr (CInt -> CInt -> CInt -> CInt -> Color -> Color -> IO ())

c'drawRectangleGradientEx :: Ptr Rectangle -> Ptr Color -> Ptr Color -> Ptr Color -> Ptr Color -> IO ()

drawRectangleGradientEx :: Rectangle -> Color -> Color -> Color -> Color -> IO ()

p'drawRectangleGradientEx :: FunPtr (Rectangle -> Color -> Color -> Color -> Color -> IO ())

c'drawRectangleLines :: CInt -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

drawRectangleLines :: Int -> Int -> Int -> Int -> Color -> IO ()

p'drawRectangleLines :: FunPtr (CInt -> CInt -> CInt -> CInt -> Color -> IO ())

c'drawRectangleLinesEx :: Ptr Rectangle -> CFloat -> Ptr Color -> IO ()

drawRectangleLinesEx :: Rectangle -> Float -> Color -> IO ()

p'drawRectangleLinesEx :: FunPtr (Rectangle -> CFloat -> Color -> IO ())

c'drawRectangleRounded :: Ptr Rectangle -> CFloat -> CInt -> Ptr Color -> IO ()

drawRectangleRounded :: Rectangle -> Float -> Int -> Color -> IO ()

p'drawRectangleRounded :: FunPtr (Rectangle -> CFloat -> CInt -> Color -> IO ())

c'drawRectangleRoundedLines :: Ptr Rectangle -> CFloat -> CInt -> CFloat -> Ptr Color -> IO ()

drawRectangleRoundedLines :: Rectangle -> Float -> Int -> Float -> Color -> IO ()

p'drawRectangleRoundedLines :: FunPtr (Rectangle -> CFloat -> CInt -> CFloat -> Color -> IO ())

c'drawTriangle :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> Ptr Color -> IO ()

drawTriangle :: Vector2 -> Vector2 -> Vector2 -> Color -> IO ()

p'drawTriangle :: FunPtr (Vector2 -> Vector2 -> Vector2 -> Color -> IO ())

c'drawTriangleLines :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> Ptr Color -> IO ()

drawTriangleLines :: Vector2 -> Vector2 -> Vector2 -> Color -> IO ()

p'drawTriangleLines :: FunPtr (Vector2 -> Vector2 -> Vector2 -> Color -> IO ())

c'drawTriangleFan :: Ptr Vector2 -> CInt -> Ptr Color -> IO ()

drawTriangleFan :: [Vector2] -> Color -> IO ()

p'drawTriangleFan :: FunPtr (Ptr Vector2 -> CInt -> Color -> IO ())

c'drawTriangleStrip :: Ptr Vector2 -> CInt -> Ptr Color -> IO ()

drawTriangleStrip :: [Vector2] -> Color -> IO ()

p'drawTriangleStrip :: FunPtr (Ptr Vector2 -> CInt -> Color -> IO ())

c'drawPoly :: Ptr Vector2 -> CInt -> CFloat -> CFloat -> Ptr Color -> IO ()

drawPoly :: Vector2 -> Int -> Float -> Float -> Color -> IO ()

p'drawPoly :: FunPtr (Vector2 -> CInt -> CFloat -> CFloat -> Color -> IO ())

c'drawPolyLines :: Ptr Vector2 -> CInt -> CFloat -> CFloat -> Ptr Color -> IO ()

drawPolyLines :: Vector2 -> Int -> Float -> Float -> Color -> IO ()

p'drawPolyLines :: FunPtr (Vector2 -> CInt -> CFloat -> CFloat -> Color -> IO ())

c'drawPolyLinesEx :: Ptr Vector2 -> CInt -> CFloat -> CFloat -> CFloat -> Ptr Color -> IO ()

drawPolyLinesEx :: Vector2 -> Int -> Float -> Float -> Float -> Color -> IO ()

p'drawPolyLinesEx :: FunPtr (Vector2 -> CInt -> CFloat -> CFloat -> CFloat -> Color -> IO ())

c'checkCollisionRecs :: Ptr Rectangle -> Ptr Rectangle -> IO CInt

checkCollisionRecs :: Rectangle -> Rectangle -> Bool

p'checkCollisionRecs :: FunPtr (Rectangle -> Rectangle -> IO CInt)

c'checkCollisionCircles :: Ptr Vector2 -> CFloat -> Ptr Vector2 -> CFloat -> IO CInt

checkCollisionCircles :: Vector2 -> Float -> Vector2 -> Float -> Bool

p'checkCollisionCircles :: FunPtr (Vector2 -> CFloat -> Vector2 -> CFloat -> IO CInt)

c'checkCollisionCircleRec :: Ptr Vector2 -> CFloat -> Ptr Rectangle -> IO CInt

checkCollisionCircleRec :: Vector2 -> Float -> Rectangle -> Bool

p'checkCollisionCircleRec :: FunPtr (Vector2 -> CFloat -> Rectangle -> IO CInt)

c'checkCollisionPointRec :: Ptr Vector2 -> Ptr Rectangle -> IO CInt

checkCollisionPointRec :: Vector2 -> Rectangle -> Bool

p'checkCollisionPointRec :: FunPtr (Vector2 -> Rectangle -> IO CInt)

c'checkCollisionPointCircle :: Ptr Vector2 -> Ptr Vector2 -> CFloat -> IO CInt

checkCollisionPointCircle :: Vector2 -> Vector2 -> Float -> Bool

p'checkCollisionPointCircle :: FunPtr (Vector2 -> Vector2 -> CFloat -> IO CInt)

c'checkCollisionPointTriangle :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> IO CInt

checkCollisionPointTriangle :: Vector2 -> Vector2 -> Vector2 -> Vector2 -> Bool

p'checkCollisionPointTriangle :: FunPtr (Vector2 -> Vector2 -> Vector2 -> Vector2 -> IO CInt)

c'checkCollisionLines :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> IO CInt

checkCollisionLines :: Vector2 -> Vector2 -> Vector2 -> Vector2 -> Maybe Vector2

If a collision is found, returns Just collisionPoint, otherwise returns Nothing

p'checkCollisionLines :: FunPtr (Vector2 -> Vector2 -> Vector2 -> Vector2 -> Ptr Vector2 -> IO CInt)

c'checkCollisionPointLine :: Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> CInt -> IO CInt

checkCollisionPointLine :: Vector2 -> Vector2 -> Vector2 -> Int -> Bool

p'checkCollisionPointLine :: FunPtr (Vector2 -> Vector2 -> Vector2 -> CInt -> IO CInt)

c'getCollisionRec :: Ptr Rectangle -> Ptr Rectangle -> IO (Ptr Rectangle)

getCollisionRec :: Rectangle -> Rectangle -> Rectangle

p'getCollisionRec :: FunPtr (Rectangle -> Rectangle -> IO Rectangle)

c'loadImage :: CString -> IO (Ptr Image)

loadImage :: String -> IO Image

p'loadImage :: FunPtr (CString -> IO Image)

c'loadImageRaw :: CString -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Image)

loadImageRaw :: String -> Int -> Int -> Int -> Int -> IO Image

p'loadImageRaw :: FunPtr (CString -> CInt -> CInt -> CInt -> CInt -> IO Image)

c'loadImageAnim :: CString -> Ptr CInt -> IO (Ptr Image)

loadImageAnim :: String -> IO (Image, Int)

Returns the final image and the framees in a tuple, e.g. (img, 18)

p'loadImageAnim :: FunPtr (CString -> Ptr CInt -> IO Image)

c'loadImageFromMemory :: CString -> Ptr CUChar -> CInt -> IO (Ptr Image)

loadImageFromMemory :: String -> [Integer] -> IO Image

p'loadImageFromMemory :: FunPtr (CString -> Ptr CUChar -> CInt -> IO Image)

c'loadImageFromTexture :: Ptr Texture -> IO (Ptr Image)

loadImageFromTexture :: Texture -> IO Image

p'loadImageFromTexture :: FunPtr (Texture -> IO Image)

c'loadImageFromScreen :: IO (Ptr Image)

loadImageFromScreen :: IO Image

p'loadImageFromScreen :: FunPtr (IO Image)

c'unloadImage :: Ptr Image -> IO ()

unloadImage :: Image -> IO ()

p'unloadImage :: FunPtr (Image -> IO ())

c'exportImage :: Ptr Image -> CString -> IO CInt

exportImage :: Image -> String -> IO Bool

p'exportImage :: FunPtr (Image -> CString -> IO CInt)

c'exportImageAsCode :: Ptr Image -> CString -> IO CInt

exportImageAsCode :: Image -> String -> IO Bool

p'exportImageAsCode :: FunPtr (Image -> CString -> IO CInt)

c'genImageColor :: CInt -> CInt -> Ptr Color -> IO (Ptr Image)

genImageColor :: Int -> Int -> Color -> IO Image

p'genImageColor :: FunPtr (CInt -> CInt -> Color -> IO Image)

c'genImageGradientV :: CInt -> CInt -> Ptr Color -> Ptr Color -> IO (Ptr Image)

genImageGradientV :: Int -> Int -> Color -> Color -> IO Image

p'genImageGradientV :: FunPtr (CInt -> CInt -> Color -> Color -> IO Image)

c'genImageGradientH :: CInt -> CInt -> Ptr Color -> Ptr Color -> IO (Ptr Image)

genImageGradientH :: Int -> Int -> Color -> Color -> IO Image

p'genImageGradientH :: FunPtr (CInt -> CInt -> Color -> Color -> IO Image)

c'genImageGradientRadial :: CInt -> CInt -> CFloat -> Ptr Color -> Ptr Color -> IO (Ptr Image)

genImageGradientRadial :: Int -> Int -> Float -> Color -> Color -> IO Image

p'genImageGradientRadial :: FunPtr (CInt -> CInt -> CFloat -> Color -> Color -> IO Image)

c'genImageChecked :: CInt -> CInt -> CInt -> CInt -> Ptr Color -> Ptr Color -> IO (Ptr Image)

genImageChecked :: Int -> Int -> Int -> Int -> Color -> Color -> IO Image

p'genImageChecked :: FunPtr (CInt -> CInt -> CInt -> CInt -> Color -> Color -> IO Image)

c'genImageWhiteNoise :: CInt -> CInt -> CFloat -> IO (Ptr Image)

genImageWhiteNoise :: Int -> Int -> Float -> IO Image

p'genImageWhiteNoise :: FunPtr (CInt -> CInt -> CFloat -> IO Image)

c'genImagePerlinNoise :: CInt -> CInt -> CInt -> CInt -> CFloat -> IO (Ptr Image)

genImagePerlinNoise :: Int -> Int -> Int -> Int -> Float -> IO Image

p'genImagePerlinNoise :: FunPtr (CInt -> CInt -> CInt -> CInt -> CFloat -> IO Image)

c'genImageCellular :: CInt -> CInt -> CInt -> IO (Ptr Image)

genImageCellular :: Int -> Int -> Int -> IO Image

p'genImageCellular :: FunPtr (CInt -> CInt -> CInt -> IO Image)

c'imageCopy :: Ptr Image -> IO (Ptr Image)

imageCopy :: Image -> IO Image

p'imageCopy :: FunPtr (Image -> IO Image)

c'imageFromImage :: Ptr Image -> Ptr Rectangle -> IO (Ptr Image)

imageFromImage :: Image -> Rectangle -> IO Image

p'imageFromImage :: FunPtr (Image -> Rectangle -> IO Image)

c'imageText :: CString -> CInt -> Ptr Color -> IO (Ptr Image)

imageText :: String -> Int -> Color -> IO Image

p'imageText :: FunPtr (CString -> CInt -> Color -> IO Image)

c'imageTextEx :: Ptr Font -> CString -> CFloat -> CFloat -> Ptr Color -> IO (Ptr Image)

imageTextEx :: Font -> String -> Float -> Float -> Color -> IO Image

p'imageTextEx :: FunPtr (Font -> CString -> CFloat -> CFloat -> Color -> IO Image)

c'imageFormat :: Ptr Image -> CInt -> IO ()

imageFormat :: Image -> Int -> IO Image

p'imageFormat :: FunPtr (Ptr Image -> CInt -> IO ())

c'imageToPOT :: Ptr Image -> Ptr Color -> IO ()

imageToPOT :: Image -> Color -> IO Image

p'imageToPOT :: FunPtr (Ptr Image -> Color -> IO ())

c'imageCrop :: Ptr Image -> Ptr Rectangle -> IO ()

imageCrop :: Image -> Rectangle -> IO Image

p'imageCrop :: FunPtr (Ptr Image -> Rectangle -> IO ())

c'imageAlphaCrop :: Ptr Image -> CFloat -> IO ()

imageAlphaCrop :: Image -> Float -> IO Image

p'imageAlphaCrop :: FunPtr (Ptr Image -> CFloat -> IO ())

c'imageAlphaClear :: Ptr Image -> Ptr Color -> CFloat -> IO ()

imageAlphaClear :: Image -> Color -> Float -> IO Image

p'imageAlphaClear :: FunPtr (Ptr Image -> Color -> CFloat -> IO ())

c'imageAlphaMask :: Ptr Image -> Ptr Image -> IO ()

imageAlphaMask :: Image -> Image -> IO Image

p'imageAlphaMask :: FunPtr (Ptr Image -> Image -> IO ())

c'imageAlphaPremultiply :: Ptr Image -> IO ()

imageAlphaPremultiply :: Image -> IO Image

p'imageAlphaPremultiply :: FunPtr (Ptr Image -> IO ())

c'imageResize :: Ptr Image -> CInt -> CInt -> IO ()

imageResize :: Image -> Int -> Int -> IO Image

p'imageResize :: FunPtr (Ptr Image -> CInt -> CInt -> IO ())

c'imageResizeNN :: Ptr Image -> CInt -> CInt -> IO ()

imageResizeNN :: Image -> Int -> Int -> IO Image

p'imageResizeNN :: FunPtr (Ptr Image -> CInt -> CInt -> IO ())

c'imageResizeCanvas :: Ptr Image -> CInt -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

imageResizeCanvas :: Image -> Int -> Int -> Int -> Int -> Color -> IO Image

p'imageResizeCanvas :: FunPtr (Ptr Image -> CInt -> CInt -> CInt -> CInt -> Color -> IO ())

c'imageMipmaps :: Ptr Image -> IO ()

imageMipmaps :: Image -> IO Image

p'imageMipmaps :: FunPtr (Ptr Image -> IO ())

c'imageDither :: Ptr Image -> CInt -> CInt -> CInt -> CInt -> IO ()

imageDither :: Image -> Int -> Int -> Int -> Int -> IO Image

p'imageDither :: FunPtr (Ptr Image -> CInt -> CInt -> CInt -> CInt -> IO ())

c'imageFlipVertical :: Ptr Image -> IO ()

imageFlipVertical :: Image -> IO Image

p'imageFlipVertical :: FunPtr (Ptr Image -> IO ())

c'imageFlipHorizontal :: Ptr Image -> IO ()

imageFlipHorizontal :: Image -> IO Image

p'imageFlipHorizontal :: FunPtr (Ptr Image -> IO ())

c'imageRotateCW :: Ptr Image -> IO ()

imageRotateCW :: Image -> IO Image

p'imageRotateCW :: FunPtr (Ptr Image -> IO ())

c'imageRotateCCW :: Ptr Image -> IO ()

imageRotateCCW :: Image -> IO Image

p'imageRotateCCW :: FunPtr (Ptr Image -> IO ())

c'imageColorTint :: Ptr Image -> Ptr Color -> IO ()

imageColorTint :: Image -> Color -> IO Image

p'imageColorTint :: FunPtr (Ptr Image -> Color -> IO ())

c'imageColorInvert :: Ptr Image -> IO ()

imageColorInvert :: Image -> IO Image

p'imageColorInvert :: FunPtr (Ptr Image -> IO ())

c'imageColorGrayscale :: Ptr Image -> IO ()

imageColorGrayscale :: Image -> IO Image

p'imageColorGrayscale :: FunPtr (Ptr Image -> IO ())

c'imageColorContrast :: Ptr Image -> CFloat -> IO ()

imageColorContrast :: Image -> Float -> IO Image

p'imageColorContrast :: FunPtr (Ptr Image -> CFloat -> IO ())

c'imageColorBrightness :: Ptr Image -> CInt -> IO ()

imageColorBrightness :: Image -> Int -> IO Image

p'imageColorBrightness :: FunPtr (Ptr Image -> CInt -> IO ())

c'imageColorReplace :: Ptr Image -> Ptr Color -> Ptr Color -> IO ()

imageColorReplace :: Image -> Color -> Color -> IO Image

p'imageColorReplace :: FunPtr (Ptr Image -> Color -> Color -> IO ())

c'loadImageColors :: Ptr Image -> IO (Ptr Color)

loadImageColors :: Image -> IO [Color]

p'loadImageColors :: FunPtr (Image -> IO (Ptr Color))

c'loadImagePalette :: Ptr Image -> CInt -> Ptr CInt -> IO (Ptr Color)

loadImagePalette :: Image -> Int -> IO [Color]

p'loadImagePalette :: FunPtr (Image -> CInt -> Ptr CInt -> IO (Ptr Color))

unloadImageColors :: Ptr Color -> IO ()

NOTE: You usually won't need to use this. loadImageColors unloads the colors automatically. Only use this when you are using c'loadImageColors to load the colors.

p'unloadImageColors :: FunPtr (Ptr Color -> IO ())

unloadImagePalette :: Ptr Color -> IO ()

NOTE: You usually won't need to use this. loadImagePalette unloads the colors automatically. Only use this when you are using c'loadImagePalette to load the colors.

p'unloadImagePalette :: FunPtr (Ptr Color -> IO ())

c'getImageAlphaBorder :: Ptr Image -> CFloat -> IO (Ptr Rectangle)

getImageAlphaBorder :: Image -> Float -> IO Rectangle

p'getImageAlphaBorder :: FunPtr (Image -> CFloat -> IO Rectangle)

c'getImageColor :: Ptr Image -> CInt -> CInt -> IO (Ptr Color)

getImageColor :: Image -> Int -> Int -> IO Color

p'getImageColor :: FunPtr (Image -> CInt -> CInt -> IO Color)

c'imageClearBackground :: Ptr Image -> Ptr Color -> IO ()

imageClearBackground :: Image -> Color -> IO Image

p'imageClearBackground :: FunPtr (Ptr Image -> Color -> IO ())

c'imageDrawPixel :: Ptr Image -> CInt -> CInt -> Ptr Color -> IO ()

imageDrawPixel :: Image -> Int -> Int -> Color -> IO Image

p'imageDrawPixel :: FunPtr (Ptr Image -> CInt -> CInt -> Color -> IO ())

c'imageDrawPixelV :: Ptr Image -> Ptr Vector2 -> Ptr Color -> IO ()

imageDrawPixelV :: Image -> Vector2 -> Color -> IO Image

p'imageDrawPixelV :: FunPtr (Ptr Image -> Vector2 -> Color -> IO ())

c'imageDrawLine :: Ptr Image -> CInt -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

imageDrawLine :: Image -> Int -> Int -> Int -> Int -> Color -> IO Image

p'imageDrawLine :: FunPtr (Ptr Image -> CInt -> CInt -> CInt -> CInt -> Color -> IO ())

c'imageDrawLineV :: Ptr Image -> Ptr Vector2 -> Ptr Vector2 -> Ptr Color -> IO ()

imageDrawLineV :: Image -> Vector2 -> Vector2 -> Color -> IO Image

p'imageDrawLineV :: FunPtr (Ptr Image -> Vector2 -> Vector2 -> Color -> IO ())

c'imageDrawCircle :: Ptr Image -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

imageDrawCircle :: Image -> Int -> Int -> Int -> Color -> IO Image

p'imageDrawCircle :: FunPtr (Ptr Image -> CInt -> CInt -> CInt -> Color -> IO ())

c'imageDrawCircleV :: Ptr Image -> Ptr Vector2 -> CInt -> Ptr Color -> IO ()

imageDrawCircleV :: Image -> Vector2 -> Int -> Color -> IO Image

p'imageDrawCircleV :: FunPtr (Ptr Image -> Vector2 -> CInt -> Color -> IO ())

c'imageDrawCircleLines :: Ptr Image -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

imageDrawCircleLines :: Image -> Int -> Int -> Int -> Color -> IO Image

p'imageDrawCircleLines :: FunPtr (Ptr Image -> Vector2 -> CInt -> Color -> IO ())

c'imageDrawCircleLinesV :: Ptr Image -> Ptr Vector2 -> CInt -> Ptr Color -> IO ()

imageDrawCircleLinesV :: Image -> Vector2 -> Int -> Color -> IO Image

p'imageDrawCircleLinesV :: FunPtr (Ptr Image -> Vector2 -> CInt -> Color -> IO ())

c'imageDrawRectangle :: Ptr Image -> CInt -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

imageDrawRectangle :: Image -> Int -> Int -> Int -> Int -> Color -> IO Image

p'imageDrawRectangle :: FunPtr (Ptr Image -> CInt -> CInt -> CInt -> CInt -> Color -> IO ())

c'imageDrawRectangleV :: Ptr Image -> Ptr Vector2 -> Ptr Vector2 -> Ptr Color -> IO ()

imageDrawRectangleV :: Image -> Vector2 -> Vector2 -> Color -> IO Image

p'imageDrawRectangleV :: FunPtr (Ptr Image -> Vector2 -> Vector2 -> Color -> IO ())

c'imageDrawRectangleRec :: Ptr Image -> Ptr Rectangle -> Ptr Color -> IO ()

imageDrawRectangleRec :: Image -> Rectangle -> Color -> IO Image

p'imageDrawRectangleRec :: FunPtr (Ptr Image -> Rectangle -> Color -> IO ())

c'imageDrawRectangleLines :: Ptr Image -> Ptr Rectangle -> CInt -> Ptr Color -> IO ()

imageDrawRectangleLines :: Image -> Rectangle -> Int -> Color -> IO Image

p'imageDrawRectangleLines :: FunPtr (Ptr Image -> Rectangle -> CInt -> Color -> IO ())

c'imageDraw :: Ptr Image -> Ptr Image -> Ptr Rectangle -> Ptr Rectangle -> Ptr Color -> IO ()

imageDraw :: Image -> Image -> Rectangle -> Rectangle -> Color -> IO Image

p'imageDraw :: FunPtr (Ptr Image -> Image -> Rectangle -> Rectangle -> Color -> IO ())

c'imageDrawText :: Ptr Image -> CString -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

imageDrawText :: Image -> String -> Int -> Int -> Int -> Color -> IO Image

p'imageDrawText :: FunPtr (Ptr Image -> CString -> CInt -> CInt -> CInt -> Color -> IO ())

c'imageDrawTextEx :: Ptr Image -> Ptr Font -> CString -> Ptr Vector2 -> CFloat -> CFloat -> Ptr Color -> IO ()

imageDrawTextEx :: Image -> Font -> String -> Vector2 -> Float -> Float -> Color -> IO Image

p'imageDrawTextEx :: FunPtr (Ptr Image -> Font -> CString -> Vector2 -> CFloat -> CFloat -> Color -> IO ())

c'loadTexture :: CString -> IO (Ptr Texture)

loadTexture :: String -> IO Texture

p'loadTexture :: FunPtr (CString -> IO Texture)

c'loadTextureFromImage :: Ptr Image -> IO (Ptr Texture)

loadTextureFromImage :: Image -> IO Texture

p'loadTextureFromImage :: FunPtr (Image -> IO Texture)

c'loadTextureCubemap :: Ptr Image -> CInt -> IO (Ptr Texture)

loadTextureCubemap :: Image -> Int -> IO Texture

p'loadTextureCubemap :: FunPtr (Image -> CInt -> IO Texture)

c'loadRenderTexture :: CInt -> CInt -> IO (Ptr RenderTexture)

loadRenderTexture :: Int -> Int -> IO RenderTexture

p'loadRenderTexture :: FunPtr (CInt -> CInt -> IO RenderTexture)

c'unloadTexture :: Ptr Texture -> IO ()

unloadTexture :: Texture -> IO ()

p'unloadTexture :: FunPtr (Texture -> IO ())

c'unloadRenderTexture :: Ptr RenderTexture -> IO ()

unloadRenderTexture :: RenderTexture -> IO ()

p'unloadRenderTexture :: FunPtr (RenderTexture -> IO ())

c'updateTexture :: Ptr Texture -> Ptr () -> IO ()

updateTexture :: Texture -> Ptr () -> IO Texture

p'updateTexture :: FunPtr (Texture -> Ptr () -> IO ())

c'updateTextureRec :: Ptr Texture -> Ptr Rectangle -> Ptr () -> IO ()

updateTextureRec :: Texture -> Rectangle -> Ptr () -> IO Texture

p'updateTextureRec :: FunPtr (Texture -> Rectangle -> Ptr () -> IO ())

c'genTextureMipmaps :: Ptr Texture -> IO ()

genTextureMipmaps :: Texture -> IO Texture

p'genTextureMipmaps :: FunPtr (Ptr Texture -> IO ())

c'setTextureFilter :: Ptr Texture -> CInt -> IO ()

setTextureFilter :: Texture -> Int -> IO Texture

p'setTextureFilter :: FunPtr (Texture -> CInt -> IO ())

c'setTextureWrap :: Ptr Texture -> CInt -> IO ()

setTextureWrap :: Texture -> Int -> IO Texture

p'setTextureWrap :: FunPtr (Texture -> CInt -> IO ())

c'drawTexture :: Ptr Texture -> CInt -> CInt -> Ptr Color -> IO ()

drawTexture :: Texture -> CInt -> CInt -> Color -> IO ()

p'drawTexture :: FunPtr (Texture -> CInt -> CInt -> Color -> IO ())

c'drawTextureV :: Ptr Texture -> Ptr Vector2 -> Ptr Color -> IO ()

drawTextureV :: Texture -> Vector2 -> Color -> IO ()

p'drawTextureV :: FunPtr (Texture -> Vector2 -> Color -> IO ())

c'drawTextureEx :: Ptr Texture -> Ptr Vector2 -> CFloat -> CFloat -> Ptr Color -> IO ()

drawTextureEx :: Texture -> Vector2 -> Float -> Float -> Color -> IO ()

p'drawTextureEx :: FunPtr (Texture -> Vector2 -> CFloat -> CFloat -> Color -> IO ())

c'drawTextureRec :: Ptr Texture -> Ptr Rectangle -> Ptr Vector2 -> Ptr Color -> IO ()

drawTextureRec :: Texture -> Rectangle -> Vector2 -> Color -> IO ()

p'drawTextureRec :: FunPtr (Texture -> Rectangle -> Vector2 -> Color -> IO ())

c'drawTextureQuad :: Ptr Texture -> Ptr Vector2 -> Ptr Vector2 -> Ptr Rectangle -> Ptr Color -> IO ()

drawTextureQuad :: Texture -> Vector2 -> Vector2 -> Rectangle -> Color -> IO ()

p'drawTextureQuad :: FunPtr (Texture -> Vector2 -> Vector2 -> Rectangle -> Color -> IO ())

c'drawTextureTiled :: Ptr Texture -> Ptr Rectangle -> Ptr Rectangle -> Ptr Vector2 -> CFloat -> CFloat -> Ptr Color -> IO ()

drawTextureTiled :: Texture -> Rectangle -> Rectangle -> Vector2 -> Float -> Float -> Color -> IO ()

p'drawTextureTiled :: FunPtr (Texture -> Rectangle -> Rectangle -> Vector2 -> CFloat -> CFloat -> Color -> IO ())

c'drawTexturePro :: Ptr Texture -> Ptr Rectangle -> Ptr Rectangle -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawTexturePro :: Texture -> Rectangle -> Rectangle -> Vector2 -> Float -> Color -> IO ()

p'drawTexturePro :: FunPtr (Texture -> Rectangle -> Rectangle -> Vector2 -> CFloat -> Color -> IO ())

c'drawTextureNPatch :: Ptr Texture -> Ptr NPatchInfo -> Ptr Rectangle -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawTextureNPatch :: Texture -> NPatchInfo -> Rectangle -> Vector2 -> Float -> Color -> IO ()

p'drawTextureNPatch :: FunPtr (Texture -> NPatchInfo -> Rectangle -> Vector2 -> CFloat -> Color -> IO ())

c'drawTexturePoly :: Ptr Texture -> Ptr Vector2 -> Ptr Vector2 -> Ptr Vector2 -> CInt -> Ptr Color -> IO ()

drawTexturePoly :: Texture -> Vector2 -> [Vector2] -> [Vector2] -> Color -> IO ()

p'drawTexturePoly :: FunPtr (Texture -> Vector2 -> Ptr Vector2 -> Ptr Vector2 -> CInt -> Color -> IO ())

c'fade :: Ptr Color -> CFloat -> IO (Ptr Color)

fade :: Color -> Float -> Color

p'fade :: FunPtr (Color -> CFloat -> IO Color)

c'colorToInt :: Ptr Color -> IO CInt

colorToInt :: Color -> Int

p'colorToInt :: FunPtr (Color -> IO CInt)

c'colorNormalize :: Ptr Color -> IO (Ptr Vector4)

colorNormalize :: Color -> Vector4

p'colorNormalize :: FunPtr (Color -> IO Vector4)

c'colorFromNormalized :: Ptr Vector4 -> IO (Ptr Color)

colorFromNormalized :: Vector4 -> Color

p'colorFromNormalized :: FunPtr (Vector4 -> IO Color)

c'colorToHSV :: Ptr Color -> IO (Ptr Vector3)

colorToHSV :: Color -> Vector3

p'colorToHSV :: FunPtr (Color -> IO Vector3)

c'colorFromHSV :: CFloat -> CFloat -> CFloat -> IO (Ptr Color)

colorFromHSV :: Float -> Float -> Float -> Color

p'colorFromHSV :: FunPtr (CFloat -> CFloat -> CFloat -> IO Color)

c'colorAlpha :: Ptr Color -> CFloat -> IO (Ptr Color)

colorAlpha :: Color -> Float -> Color

p'colorAlpha :: FunPtr (Color -> CFloat -> IO Color)

c'colorAlphaBlend :: Ptr Color -> Ptr Color -> Ptr Color -> IO (Ptr Color)

colorAlphaBlend :: Color -> Color -> Color -> Color

p'colorAlphaBlend :: FunPtr (Color -> Color -> Color -> IO Color)

c'getColor :: CUInt -> IO (Ptr Color)

getColor :: Integer -> Color

p'getColor :: FunPtr (CUInt -> IO Color)

c'getPixelColor :: Ptr () -> CInt -> IO (Ptr Color)

getPixelColor :: Ptr () -> Int -> IO Color

p'getPixelColor :: FunPtr (Ptr () -> CInt -> IO Color)

c'setPixelColor :: Ptr () -> Ptr Color -> CInt -> IO ()

setPixelColor :: Ptr () -> Color -> Int -> IO ()

p'setPixelColor :: FunPtr (Ptr () -> Color -> CInt -> IO ())

c'getPixelDataSize :: CInt -> CInt -> CInt -> IO CInt

getPixelDataSize :: Int -> Int -> Int -> Int

p'getPixelDataSize :: FunPtr (CInt -> CInt -> CInt -> IO CInt)

c'getFontDefault :: IO (Ptr Font)

getFontDefault :: IO Font

p'getFontDefault :: FunPtr (IO Font)

c'loadFont :: CString -> IO (Ptr Font)

loadFont :: String -> IO Font

p'loadFont :: FunPtr (CString -> IO Font)

c'loadFontEx :: CString -> CInt -> Ptr CInt -> CInt -> IO (Ptr Font)

loadFontEx :: String -> Int -> [Int] -> Int -> IO Font

p'loadFontEx :: FunPtr (CString -> CInt -> Ptr CInt -> CInt -> IO Font)

c'loadFontFromImage :: Ptr Image -> Ptr Color -> CInt -> IO (Ptr Font)

loadFontFromImage :: Image -> Color -> Int -> IO Font

p'loadFontFromImage :: FunPtr (Image -> Color -> CInt -> IO Font)

c'loadFontFromMemory :: CString -> Ptr CUChar -> CInt -> CInt -> Ptr CInt -> CInt -> IO (Ptr Font)

loadFontFromMemory :: String -> [Integer] -> Int -> [Int] -> Int -> IO Font

p'loadFontFromMemory :: FunPtr (CString -> Ptr CUChar -> CInt -> CInt -> Ptr CInt -> CInt -> IO Font)

c'loadFontData :: Ptr CUChar -> CInt -> CInt -> Ptr CInt -> CInt -> CInt -> IO (Ptr GlyphInfo)

loadFontData :: [Integer] -> Int -> [Int] -> Int -> Int -> IO GlyphInfo

p'loadFontData :: FunPtr (Ptr CUChar -> CInt -> CInt -> Ptr CInt -> CInt -> CInt -> IO (Ptr GlyphInfo))

c'genImageFontAtlas :: Ptr GlyphInfo -> Ptr (Ptr Rectangle) -> CInt -> CInt -> CInt -> CInt -> IO (Ptr Image)

genImageFontAtlas :: [GlyphInfo] -> [[Rectangle]] -> Int -> Int -> Int -> Int -> IO Image

p'genImageFontAtlas :: FunPtr (Ptr GlyphInfo -> Ptr (Ptr Rectangle) -> CInt -> CInt -> CInt -> CInt -> IO Image)

c'unloadFontData :: Ptr GlyphInfo -> CInt -> IO ()

unloadFontData :: [GlyphInfo] -> IO ()

p'unloadFontData :: FunPtr (Ptr GlyphInfo -> CInt -> IO ())

c'unloadFont :: Ptr Font -> IO ()

unloadFont :: Font -> IO ()

p'unloadFont :: FunPtr (Font -> IO ())

c'exportFontAsCode :: Ptr Font -> CString -> IO CInt

exportFontAsCode :: Font -> String -> IO Bool

p'exportFontAsCode :: FunPtr (Font -> CString -> IO CInt)

c'drawFPS :: CInt -> CInt -> IO ()

drawFPS :: Int -> Int -> IO ()

p'drawFPS :: FunPtr (CInt -> CInt -> IO ())

c'drawText :: CString -> CInt -> CInt -> CInt -> Ptr Color -> IO ()

drawText :: String -> Int -> Int -> Int -> Color -> IO ()

p'drawText :: FunPtr (CString -> CInt -> CInt -> CInt -> Color -> IO ())

c'drawTextEx :: Ptr Font -> CString -> Ptr Vector2 -> CFloat -> CFloat -> Ptr Color -> IO ()

drawTextEx :: Font -> String -> Vector2 -> Float -> Float -> Color -> IO ()

p'drawTextEx :: FunPtr (Font -> CString -> Vector2 -> CFloat -> CFloat -> Color -> IO ())

c'drawTextPro :: Ptr Font -> CString -> Ptr Vector2 -> Ptr Vector2 -> CFloat -> CFloat -> CFloat -> Ptr Color -> IO ()

drawTextPro :: Font -> String -> Vector2 -> Vector2 -> Float -> Float -> Float -> Color -> IO ()

p'drawTextPro :: FunPtr (Font -> CString -> Vector2 -> Vector2 -> CFloat -> CFloat -> CFloat -> Color -> IO ())

c'drawTextCodepoint :: Ptr Font -> CInt -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawTextCodepoint :: Font -> Int -> Vector2 -> Float -> Color -> IO ()

p'drawTextCodepoint :: FunPtr (Font -> CInt -> Vector2 -> CFloat -> Color -> IO ())

c'drawTextCodepoints :: Ptr Font -> Ptr CInt -> CInt -> Ptr Vector2 -> CFloat -> CFloat -> Ptr Color -> IO ()

drawTextCodepoints :: Font -> [Int] -> Vector2 -> Float -> Float -> Color -> IO ()

p'drawTextCodepoints :: FunPtr (Font -> Ptr CInt -> CInt -> Vector2 -> CFloat -> CFloat -> Color -> IO ())

c'measureText :: CString -> CInt -> IO CInt

measureText :: String -> Int -> IO Int

p'measureText :: FunPtr (CString -> CInt -> IO CInt)

c'measureTextEx :: Ptr Font -> CString -> CFloat -> CFloat -> IO (Ptr Vector2)

measureTextEx :: Font -> String -> Float -> Float -> IO Vector2

p'measureTextEx :: FunPtr (Font -> CString -> CFloat -> CFloat -> IO Vector2)

c'getGlyphIndex :: Ptr Font -> CInt -> IO CInt

getGlyphIndex :: Font -> Int -> IO Int

p'getGlyphIndex :: FunPtr (Font -> CInt -> IO CInt)

c'getGlyphInfo :: Ptr Font -> CInt -> IO (Ptr GlyphInfo)

getGlyphInfo :: Font -> Int -> IO GlyphInfo

p'getGlyphInfo :: FunPtr (Font -> CInt -> IO GlyphInfo)

c'getGlyphAtlasRec :: Ptr Font -> CInt -> IO (Ptr Rectangle)

getGlyphAtlasRec :: Font -> Int -> IO Rectangle

p'getGlyphAtlasRec :: FunPtr (Font -> CInt -> IO Rectangle)

c'loadUTF8 :: Ptr CInt -> CInt -> IO CString

loadUTF8 :: [Integer] -> IO String

p'loadUTF8 :: FunPtr (Ptr CInt -> CInt -> IO CString)

unloadUTF8 :: CString -> IO ()

p'unloadUTF8 :: FunPtr (CString -> IO ())

c'loadCodepoints :: CString -> Ptr CInt -> IO (Ptr CInt)

loadCodepoints :: String -> IO [Int]

p'loadCodepoints :: FunPtr (CString -> Ptr CInt -> IO (Ptr CInt))

unloadCodepoints :: Ptr CInt -> IO ()

p'unloadCodepoints :: FunPtr (Ptr CInt -> IO ())

c'getCodepointCount :: CString -> IO CInt

getCodepointCount :: String -> IO Int

p'getCodepointCount :: FunPtr (CString -> IO CInt)

getCodepoint :: CString -> Ptr CInt -> IO CInt

Deprecated, use getCodepointNext

p'getCodepoint :: FunPtr (CString -> Ptr CInt -> IO CInt)

c'getCodepointNext :: CString -> Ptr CInt -> IO CInt

getCodepointNext :: String -> IO (Int, Int)

p'getCodepointNext :: FunPtr (CString -> Ptr CInt -> IO CInt)

c'getCodepointPrevious :: CString -> Ptr CInt -> IO CInt

getCodepointPrevious :: String -> IO (Int, Int)

p'getCodepointPrevious :: FunPtr (CString -> Ptr CInt -> IO CInt)

c'codepointToUTF8 :: CInt -> Ptr CInt -> IO CString

codepointToUTF8 :: Int -> IO String

p'codepointToUTF8 :: FunPtr (CInt -> Ptr CInt -> IO CString)

textCopy :: CString -> CString -> IO CInt

Not required in Haskell

p'textCopy :: FunPtr (CString -> CString -> IO CInt)

textIsEqual :: CString -> CString -> IO CInt

Not required in Haskell

p'textIsEqual :: FunPtr (CString -> CString -> IO CInt)

textLength :: CString -> IO CUInt

Not required in Haskell

p'textLength :: FunPtr (CString -> IO CUInt)

textFormat :: CString -> IO CString

Not required in Haskell

p'textFormat :: FunPtr (CString -> IO CString)

textSubtext :: CString -> CInt -> CInt -> IO CString

Not required in Haskell

p'textSubtext :: FunPtr (CString -> CInt -> CInt -> IO CString)

textReplace :: CString -> CString -> CString -> IO CString

Not required in Haskell

p'textReplace :: FunPtr (CString -> CString -> CString -> IO CString)

textInsert :: CString -> CString -> CInt -> IO CString

Not required in Haskell

p'textInsert :: FunPtr (CString -> CString -> CInt -> IO CString)

textJoin :: Ptr CString -> CInt -> CString -> IO CString

Not required in Haskell

p'textJoin :: FunPtr (Ptr CString -> CInt -> CString -> IO CString)

textSplit :: CString -> CChar -> Ptr CInt -> IO (Ptr CString)

Not required in Haskell

p'textSplit :: FunPtr (CString -> CChar -> Ptr CInt -> IO (Ptr CString))

textAppend :: CString -> CString -> Ptr CInt -> IO ()

Not required in Haskell

p'textAppend :: FunPtr (CString -> CString -> Ptr CInt -> IO ())

textFindIndex :: CString -> CString -> IO CInt

Not required in Haskell

p'textFindIndex :: FunPtr (CString -> CString -> IO CInt)

textToUpper :: CString -> IO CString

Not required in Haskell

p'textToUpper :: FunPtr (CString -> IO CString)

textToLower :: CString -> IO CString

Not required in Haskell

p'textToLower :: FunPtr (CString -> IO CString)

textToPascal :: CString -> IO CString

Not required in Haskell

p'textToPascal :: FunPtr (CString -> IO CString)

textToInteger :: CString -> IO CInt

Not required in Haskell

p'textToInteger :: FunPtr (CString -> IO CInt)

c'drawLine3D :: Ptr Vector3 -> Ptr Vector3 -> Ptr Color -> IO ()

drawLine3D :: Vector3 -> Vector3 -> Color -> IO ()

p'drawLine3D :: FunPtr (Vector3 -> Vector3 -> Color -> IO ())

c'drawPoint3D :: Ptr Vector3 -> Ptr Color -> IO ()

drawPoint3D :: Vector3 -> Color -> IO ()

p'drawPoint3D :: FunPtr (Vector3 -> Color -> IO ())

c'drawCircle3D :: Ptr Vector3 -> CFloat -> Ptr Vector3 -> CFloat -> Ptr Color -> IO ()

drawCircle3D :: Vector3 -> Float -> Vector3 -> Float -> Color -> IO ()

p'drawCircle3D :: FunPtr (Vector3 -> CFloat -> Vector3 -> CFloat -> Color -> IO ())

c'drawTriangle3D :: Ptr Vector3 -> Ptr Vector3 -> Ptr Vector3 -> Ptr Color -> IO ()

drawTriangle3D :: Vector3 -> Vector3 -> Vector3 -> Color -> IO ()

p'drawTriangle3D :: FunPtr (Vector3 -> Vector3 -> Vector3 -> Color -> IO ())

c'drawTriangleStrip3D :: Ptr Vector3 -> CInt -> Ptr Color -> IO ()

drawTriangleStrip3D :: [Vector3] -> Int -> Color -> IO ()

p'drawTriangleStrip3D :: FunPtr (Ptr Vector3 -> CInt -> Color -> IO ())

c'drawCube :: Ptr Vector3 -> CFloat -> CFloat -> CFloat -> Ptr Color -> IO ()

drawCube :: Vector3 -> Float -> Float -> Float -> Color -> IO ()

p'drawCube :: FunPtr (Vector3 -> CFloat -> CFloat -> CFloat -> Color -> IO ())

c'drawCubeV :: Ptr Vector3 -> Ptr Vector3 -> Ptr Color -> IO ()

drawCubeV :: Vector3 -> Vector3 -> Color -> IO ()

p'drawCubeV :: FunPtr (Vector3 -> Vector3 -> Color -> IO ())

c'drawCubeWires :: Ptr Vector3 -> CFloat -> CFloat -> CFloat -> Ptr Color -> IO ()

drawCubeWires :: Vector3 -> Float -> Float -> Float -> Color -> IO ()

p'drawCubeWires :: FunPtr (Vector3 -> CFloat -> CFloat -> CFloat -> Color -> IO ())

c'drawCubeWiresV :: Ptr Vector3 -> Ptr Vector3 -> Ptr Color -> IO ()

drawCubeWiresV :: Vector3 -> Vector3 -> Color -> IO ()

p'drawCubeWiresV :: FunPtr (Vector3 -> Vector3 -> Color -> IO ())

c'drawCubeTexture :: Ptr Texture -> Ptr Vector3 -> CFloat -> CFloat -> CFloat -> Ptr Color -> IO ()

drawCubeTexture :: Texture -> Vector3 -> Float -> Float -> Float -> Color -> IO ()

p'drawCubeTexture :: FunPtr (Texture -> Vector3 -> CFloat -> CFloat -> CFloat -> Color -> IO ())

c'drawCubeTextureRec :: Ptr Texture -> Ptr Rectangle -> Ptr Vector3 -> CFloat -> CFloat -> CFloat -> Ptr Color -> IO ()

drawCubeTextureRec :: Texture -> Rectangle -> Vector3 -> Float -> Float -> Float -> Color -> IO ()

p'drawCubeTextureRec :: FunPtr (Texture -> Rectangle -> Vector3 -> CFloat -> CFloat -> CFloat -> Color -> IO ())

c'drawSphere :: Ptr Vector3 -> CFloat -> Ptr Color -> IO ()

drawSphere :: Vector3 -> Float -> Color -> IO ()

p'drawSphere :: FunPtr (Vector3 -> CFloat -> Color -> IO ())

c'drawSphereEx :: Ptr Vector3 -> CFloat -> CInt -> CInt -> Ptr Color -> IO ()

drawSphereEx :: Vector3 -> Float -> Int -> Int -> Color -> IO ()

p'drawSphereEx :: FunPtr (Vector3 -> CFloat -> CInt -> CInt -> Color -> IO ())

c'drawSphereWires :: Ptr Vector3 -> CFloat -> CInt -> CInt -> Ptr Color -> IO ()

drawSphereWires :: Vector3 -> Float -> Int -> Int -> Color -> IO ()

p'drawSphereWires :: FunPtr (Vector3 -> CFloat -> CInt -> CInt -> Color -> IO ())

c'drawCylinder :: Ptr Vector3 -> CFloat -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawCylinder :: Vector3 -> Float -> Float -> Float -> Int -> Color -> IO ()

p'drawCylinder :: FunPtr (Vector3 -> CFloat -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawCylinderEx :: Ptr Vector3 -> Ptr Vector3 -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawCylinderEx :: Vector3 -> Vector3 -> Float -> Float -> Int -> Color -> IO ()

p'drawCylinderEx :: FunPtr (Vector3 -> Vector3 -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawCylinderWires :: Ptr Vector3 -> CFloat -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawCylinderWires :: Vector3 -> Float -> Float -> Float -> Int -> Color -> IO ()

p'drawCylinderWires :: FunPtr (Vector3 -> CFloat -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawCylinderWiresEx :: Ptr Vector3 -> Ptr Vector3 -> CFloat -> CFloat -> CInt -> Ptr Color -> IO ()

drawCylinderWiresEx :: Vector3 -> Vector3 -> Float -> Float -> Int -> Color -> IO ()

p'drawCylinderWiresEx :: FunPtr (Vector3 -> Vector3 -> CFloat -> CFloat -> CInt -> Color -> IO ())

c'drawPlane :: Ptr Vector3 -> Ptr Vector2 -> Ptr Color -> IO ()

drawPlane :: Vector3 -> Vector2 -> Color -> IO ()

p'drawPlane :: FunPtr (Vector3 -> Vector2 -> Color -> IO ())

c'drawRay :: Ptr Ray -> Ptr Color -> IO ()

drawRay :: Ray -> Color -> IO ()

p'drawRay :: FunPtr (Ray -> Color -> IO ())

c'drawGrid :: CInt -> CFloat -> IO ()

drawGrid :: Int -> Float -> IO ()

p'drawGrid :: FunPtr (CInt -> CFloat -> IO ())

c'loadModel :: CString -> IO (Ptr Model)

loadModel :: String -> IO Model

p'loadModel :: FunPtr (CString -> IO Model)

c'loadModelFromMesh :: Ptr Mesh -> IO (Ptr Model)

loadModelFromMesh :: Mesh -> IO Model

p'loadModelFromMesh :: FunPtr (Mesh -> IO Model)

c'unloadModel :: Ptr Model -> IO ()

unloadModel :: Model -> IO ()

p'unloadModel :: FunPtr (Model -> IO ())

c'unloadModelKeepMeshes :: Ptr Model -> IO ()

unloadModelKeepMeshes :: Model -> IO ()

p'unloadModelKeepMeshes :: FunPtr (Model -> IO ())

c'getModelBoundingBox :: Ptr Model -> IO (Ptr BoundingBox)

getModelBoundingBox :: Model -> IO BoundingBox

p'getModelBoundingBox :: FunPtr (Model -> IO BoundingBox)

c'drawModel :: Ptr Model -> Ptr Vector3 -> CFloat -> Ptr Color -> IO ()

drawModel :: Model -> Vector3 -> Float -> Color -> IO ()

p'drawModel :: FunPtr (Model -> Vector3 -> CFloat -> Color -> IO ())

c'drawModelEx :: Ptr Model -> Ptr Vector3 -> Ptr Vector3 -> CFloat -> Ptr Vector3 -> Ptr Color -> IO ()

drawModelEx :: Model -> Vector3 -> Vector3 -> Float -> Vector3 -> Color -> IO ()

p'drawModelEx :: FunPtr (Model -> Vector3 -> Vector3 -> CFloat -> Vector3 -> Color -> IO ())

c'drawModelWires :: Ptr Model -> Ptr Vector3 -> CFloat -> Ptr Color -> IO ()

drawModelWires :: Model -> Vector3 -> Float -> Color -> IO ()

p'drawModelWires :: FunPtr (Model -> Vector3 -> CFloat -> Color -> IO ())

c'drawModelWiresEx :: Ptr Model -> Ptr Vector3 -> Ptr Vector3 -> CFloat -> Ptr Vector3 -> Ptr Color -> IO ()

drawModelWiresEx :: Model -> Vector3 -> Vector3 -> Float -> Vector3 -> Color -> IO ()

p'drawModelWiresEx :: FunPtr (Model -> Vector3 -> Vector3 -> CFloat -> Vector3 -> Color -> IO ())

c'drawBoundingBox :: Ptr BoundingBox -> Ptr Color -> IO ()

drawBoundingBox :: BoundingBox -> Color -> IO ()

p'drawBoundingBox :: FunPtr (BoundingBox -> Color -> IO ())

c'drawBillboard :: Ptr Camera3D -> Ptr Texture -> Ptr Vector3 -> CFloat -> Ptr Color -> IO ()

drawBillboard :: Camera3D -> Texture -> Vector3 -> Float -> Color -> IO ()

p'drawBillboard :: FunPtr (Camera3D -> Texture -> Vector3 -> CFloat -> Color -> IO ())

c'drawBillboardRec :: Ptr Camera3D -> Ptr Texture -> Ptr Rectangle -> Ptr Vector3 -> Ptr Vector2 -> Ptr Color -> IO ()

drawBillboardRec :: Camera3D -> Texture -> Rectangle -> Vector3 -> Vector2 -> Color -> IO ()

p'drawBillboardRec :: FunPtr (Camera3D -> Texture -> Rectangle -> Vector3 -> Vector2 -> Color -> IO ())

c'drawBillboardPro :: Ptr Camera3D -> Ptr Texture -> Ptr Rectangle -> Ptr Vector3 -> Ptr Vector3 -> Ptr Vector2 -> Ptr Vector2 -> CFloat -> Ptr Color -> IO ()

drawBillboardPro :: Camera3D -> Texture -> Rectangle -> Vector3 -> Vector3 -> Vector2 -> Vector2 -> Float -> Color -> IO ()

p'drawBillboardPro :: FunPtr (Camera3D -> Texture -> Rectangle -> Vector3 -> Vector3 -> Vector2 -> Vector2 -> CFloat -> Color -> IO ())

c'uploadMesh :: Ptr Mesh -> CInt -> IO ()

uploadMesh :: Mesh -> Bool -> IO Mesh

p'uploadMesh :: FunPtr (Ptr Mesh -> CInt -> IO ())

c'updateMeshBuffer :: Ptr Mesh -> CInt -> Ptr () -> CInt -> CInt -> IO ()

updateMeshBuffer :: Mesh -> Int -> Ptr () -> Int -> Int -> IO ()

p'updateMeshBuffer :: FunPtr (Mesh -> CInt -> Ptr () -> CInt -> CInt -> IO ())

c'unloadMesh :: Ptr Mesh -> IO ()

unloadMesh :: Mesh -> IO ()

p'unloadMesh :: FunPtr (Mesh -> IO ())

c'drawMesh :: Ptr Mesh -> Ptr Material -> Ptr Matrix -> IO ()

drawMesh :: Mesh -> Material -> Matrix -> IO ()

p'drawMesh :: FunPtr (Mesh -> Material -> Matrix -> IO ())

c'drawMeshInstanced :: Ptr Mesh -> Ptr Material -> Ptr Matrix -> CInt -> IO ()

drawMeshInstanced :: Mesh -> Material -> [Matrix] -> IO ()

p'drawMeshInstanced :: FunPtr (Mesh -> Material -> Ptr Matrix -> CInt -> IO ())

c'exportMesh :: Ptr Mesh -> CString -> IO CInt

exportMesh :: Mesh -> String -> IO Bool

p'exportMesh :: FunPtr (Mesh -> CString -> IO CInt)

c'getMeshBoundingBox :: Ptr Mesh -> IO (Ptr BoundingBox)

getMeshBoundingBox :: Mesh -> IO BoundingBox

p'getMeshBoundingBox :: FunPtr (Mesh -> IO BoundingBox)

c'genMeshTangents :: Ptr Mesh -> IO ()

genMeshTangents :: Mesh -> IO Mesh

p'genMeshTangents :: FunPtr (Ptr Mesh -> IO ())

c'genMeshPoly :: CInt -> CFloat -> IO (Ptr Mesh)

genMeshPoly :: Int -> Float -> IO Mesh

p'genMeshPoly :: FunPtr (CInt -> CFloat -> IO Mesh)

c'genMeshPlane :: CFloat -> CFloat -> CInt -> CInt -> IO (Ptr Mesh)

genMeshPlane :: Float -> Float -> Int -> Int -> IO Mesh

p'genMeshPlane :: FunPtr (CFloat -> CFloat -> CInt -> CInt -> IO Mesh)

c'genMeshCube :: CFloat -> CFloat -> CFloat -> IO (Ptr Mesh)

genMeshCube :: Float -> Float -> Float -> IO Mesh

p'genMeshCube :: FunPtr (CFloat -> CFloat -> CFloat -> IO Mesh)

c'genMeshSphere :: CFloat -> CInt -> CInt -> IO (Ptr Mesh)

genMeshSphere :: Float -> Int -> Int -> IO Mesh

p'genMeshSphere :: FunPtr (CFloat -> CInt -> CInt -> IO Mesh)

c'genMeshHemiSphere :: CFloat -> CInt -> CInt -> IO (Ptr Mesh)

genMeshHemiSphere :: Float -> Int -> Int -> IO Mesh

p'genMeshHemiSphere :: FunPtr (CFloat -> CInt -> CInt -> IO Mesh)

c'genMeshCylinder :: CFloat -> CFloat -> CInt -> IO (Ptr Mesh)

genMeshCylinder :: Float -> Float -> Int -> IO Mesh

p'genMeshCylinder :: FunPtr (CFloat -> CFloat -> CInt -> IO Mesh)

c'genMeshCone :: CFloat -> CFloat -> CInt -> IO (Ptr Mesh)

genMeshCone :: Float -> Float -> Int -> IO Mesh

p'genMeshCone :: FunPtr (CFloat -> CFloat -> CInt -> IO Mesh)

c'genMeshTorus :: CFloat -> CFloat -> CInt -> CInt -> IO (Ptr Mesh)

genMeshTorus :: Float -> Float -> Int -> Int -> IO Mesh

p'genMeshTorus :: FunPtr (CFloat -> CFloat -> CInt -> CInt -> IO Mesh)

c'genMeshKnot :: CFloat -> CFloat -> CInt -> CInt -> IO (Ptr Mesh)

genMeshKnot :: Float -> Float -> Int -> Int -> IO Mesh

p'genMeshKnot :: FunPtr (CFloat -> CFloat -> CInt -> CInt -> IO Mesh)

c'genMeshHeightmap :: Ptr Image -> Ptr Vector3 -> IO (Ptr Mesh)

genMeshHeightmap :: Image -> Vector3 -> IO Mesh

p'genMeshHeightmap :: FunPtr (Image -> Vector3 -> IO Mesh)

c'genMeshCubicmap :: Ptr Image -> Ptr Vector3 -> IO (Ptr Mesh)

genMeshCubicmap :: Image -> Vector3 -> IO Mesh

p'genMeshCubicmap :: FunPtr (Image -> Vector3 -> IO Mesh)

c'loadMaterials :: CString -> Ptr CInt -> IO (Ptr Material)

loadMaterials :: String -> IO [Material]

p'loadMaterials :: FunPtr (CString -> Ptr CInt -> IO (Ptr Material))

c'loadMaterialDefault :: IO (Ptr Material)

loadMaterialDefault :: IO Material

p'loadMaterialDefault :: FunPtr (IO Material)

c'unloadMaterial :: Ptr Material -> IO ()

unloadMaterial :: Material -> IO ()

p'unloadMaterial :: FunPtr (Material -> IO ())

c'setMaterialTexture :: Ptr Material -> CInt -> Ptr Texture -> IO ()

setMaterialTexture :: Material -> Int -> Texture -> IO Material

p'setMaterialTexture :: FunPtr (Ptr Material -> CInt -> Texture -> IO ())

c'setModelMeshMaterial :: Ptr Model -> CInt -> CInt -> IO ()

setModelMeshMaterial :: Model -> Int -> Int -> IO Model

p'setModelMeshMaterial :: FunPtr (Ptr Model -> CInt -> CInt -> IO ())

c'loadModelAnimations :: CString -> Ptr CUInt -> IO (Ptr ModelAnimation)

loadModelAnimations :: String -> IO [ModelAnimation]

p'loadModelAnimations :: FunPtr (CString -> Ptr CUInt -> IO (Ptr ModelAnimation))

c'updateModelAnimation :: Ptr Model -> Ptr ModelAnimation -> CInt -> IO ()

updateModelAnimation :: Model -> ModelAnimation -> Int -> IO ()

p'updateModelAnimation :: FunPtr (Model -> ModelAnimation -> CInt -> IO ())

c'unloadModelAnimation :: Ptr ModelAnimation -> IO ()

unloadModelAnimation :: ModelAnimation -> IO ()

p'unloadModelAnimation :: FunPtr (ModelAnimation -> IO ())

c'unloadModelAnimations :: Ptr ModelAnimation -> CUInt -> IO ()

unloadModelAnimations :: [ModelAnimation] -> IO ()

p'unloadModelAnimations :: FunPtr (Ptr ModelAnimation -> CUInt -> IO ())

c'isModelAnimationValid :: Ptr Model -> Ptr ModelAnimation -> IO CInt

isModelAnimationValid :: Model -> ModelAnimation -> IO Bool

p'isModelAnimationValid :: FunPtr (Model -> ModelAnimation -> IO CInt)

c'checkCollisionSpheres :: Ptr Vector3 -> CFloat -> Ptr Vector3 -> CFloat -> IO CInt

checkCollisionSpheres :: Vector3 -> Float -> Vector3 -> Float -> Bool

p'checkCollisionSpheres :: FunPtr (Vector3 -> CFloat -> Vector3 -> CFloat -> IO CInt)

c'checkCollisionBoxes :: Ptr BoundingBox -> Ptr BoundingBox -> IO CInt

checkCollisionBoxes :: BoundingBox -> BoundingBox -> Bool

p'checkCollisionBoxes :: FunPtr (BoundingBox -> BoundingBox -> IO CInt)

c'checkCollisionBoxSphere :: Ptr BoundingBox -> Ptr Vector3 -> CFloat -> IO CInt

checkCollisionBoxSphere :: BoundingBox -> Vector3 -> Float -> Bool

p'checkCollisionBoxSphere :: FunPtr (BoundingBox -> Vector3 -> CFloat -> IO CInt)

c'getRayCollisionSphere :: Ptr Ray -> Ptr Vector3 -> CFloat -> IO (Ptr RayCollision)

getRayCollisionSphere :: Ray -> Vector3 -> Float -> RayCollision

p'getRayCollisionSphere :: FunPtr (Ray -> Vector3 -> CFloat -> IO RayCollision)

c'getRayCollisionBox :: Ptr Ray -> Ptr BoundingBox -> IO (Ptr RayCollision)

getRayCollisionBox :: Ray -> BoundingBox -> RayCollision

p'getRayCollisionBox :: FunPtr (Ray -> BoundingBox -> IO RayCollision)

c'getRayCollisionMesh :: Ptr Ray -> Ptr Mesh -> Ptr Matrix -> IO (Ptr RayCollision)

getRayCollisionMesh :: Ray -> Mesh -> Matrix -> RayCollision

p'getRayCollisionMesh :: FunPtr (Ray -> Mesh -> Matrix -> IO RayCollision)

c'getRayCollisionTriangle :: Ptr Ray -> Ptr Vector3 -> Ptr Vector3 -> Ptr Vector3 -> IO (Ptr RayCollision)

getRayCollisionTriangle :: Ray -> Vector3 -> Vector3 -> Vector3 -> RayCollision

p'getRayCollisionTriangle :: FunPtr (Ray -> Vector3 -> Vector3 -> Vector3 -> IO RayCollision)

c'getRayCollisionQuad :: Ptr Ray -> Ptr Vector3 -> Ptr Vector3 -> Ptr Vector3 -> Ptr Vector3 -> IO (Ptr RayCollision)

getRayCollisionQuad :: Ray -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> RayCollision

p'getRayCollisionQuad :: FunPtr (Ray -> Vector3 -> Vector3 -> Vector3 -> Vector3 -> IO RayCollision)

type AudioCallback = FunPtr (Ptr () -> CUInt -> IO ())

mk'audioCallback :: (Ptr () -> CUInt -> IO ()) -> IO AudioCallback

mK'audioCallback :: AudioCallback -> Ptr () -> CUInt -> IO ()

initAudioDevice :: IO ()

p'initAudioDevice :: FunPtr (IO ())

closeAudioDevice :: IO ()

p'closeAudioDevice :: FunPtr (IO ())

c'isAudioDeviceReady :: IO CInt

isAudioDeviceReady :: IO Bool

p'isAudioDeviceReady :: FunPtr (IO CInt)

c'setMasterVolume :: CFloat -> IO ()

setMasterVolume :: Float -> IO ()

p'setMasterVolume :: FunPtr (CFloat -> IO ())

c'loadWave :: CString -> IO (Ptr Wave)

loadWave :: String -> IO Wave

p'loadWave :: FunPtr (CString -> IO Wave)

c'loadWaveFromMemory :: CString -> Ptr CUChar -> CInt -> IO (Ptr Wave)

loadWaveFromMemory :: String -> [Integer] -> IO Wave

p'loadWaveFromMemory :: FunPtr (CString -> Ptr CUChar -> CInt -> IO Wave)

c'loadSound :: CString -> IO (Ptr Sound)

loadSound :: String -> IO Sound

p'loadSound :: FunPtr (CString -> IO Sound)

c'loadSoundFromWave :: Ptr Wave -> IO (Ptr Sound)

loadSoundFromWave :: Wave -> IO Sound

p'loadSoundFromWave :: FunPtr (Wave -> IO Sound)

c'updateSound :: Ptr Sound -> Ptr () -> CInt -> IO ()

updateSound :: Sound -> Ptr () -> Int -> IO ()

p'updateSound :: FunPtr (Sound -> Ptr () -> CInt -> IO ())

c'unloadWave :: Ptr Wave -> IO ()

unloadWave :: Wave -> IO ()

p'unloadWave :: FunPtr (Wave -> IO ())

c'unloadSound :: Ptr Sound -> IO ()

unloadSound :: Sound -> IO ()

p'unloadSound :: FunPtr (Sound -> IO ())

c'exportWave :: Ptr Wave -> CString -> IO CInt

exportWave :: Wave -> String -> IO Bool

p'exportWave :: FunPtr (Wave -> CString -> IO CInt)

c'exportWaveAsCode :: Ptr Wave -> CString -> IO CInt

exportWaveAsCode :: Wave -> String -> IO Bool

p'exportWaveAsCode :: FunPtr (Wave -> CString -> IO CInt)

c'playSound :: Ptr Sound -> IO ()

playSound :: Sound -> IO ()

p'playSound :: FunPtr (Sound -> IO ())

c'stopSound :: Ptr Sound -> IO ()

stopSound :: Sound -> IO ()

p'stopSound :: FunPtr (Sound -> IO ())

c'pauseSound :: Ptr Sound -> IO ()

pauseSound :: Sound -> IO ()

p'pauseSound :: FunPtr (Sound -> IO ())

c'resumeSound :: Ptr Sound -> IO ()

resumeSound :: Sound -> IO ()

p'resumeSound :: FunPtr (Sound -> IO ())

c'playSoundMulti :: Ptr Sound -> IO ()

playSoundMulti :: Sound -> IO ()

p'playSoundMulti :: FunPtr (Sound -> IO ())

stopSoundMulti :: IO ()

p'stopSoundMulti :: FunPtr (IO ())

c'getSoundsPlaying :: IO CInt

getSoundsPlaying :: IO Int

p'getSoundsPlaying :: FunPtr (IO CInt)

c'isSoundPlaying :: Ptr Sound -> IO CInt

isSoundPlaying :: Sound -> IO Bool

p'isSoundPlaying :: FunPtr (Sound -> IO CInt)

c'setSoundVolume :: Ptr Sound -> CFloat -> IO ()

setSoundVolume :: Sound -> Float -> IO ()

p'setSoundVolume :: FunPtr (Sound -> CFloat -> IO ())

c'setSoundPitch :: Ptr Sound -> CFloat -> IO ()

setSoundPitch :: Sound -> Float -> IO ()

p'setSoundPitch :: FunPtr (Sound -> CFloat -> IO ())

c'setSoundPan :: Ptr Sound -> CFloat -> IO ()

setSoundPan :: Sound -> Float -> IO ()

p'setSoundPan :: FunPtr (Sound -> CFloat -> IO ())

c'waveCopy :: Ptr Wave -> IO (Ptr Wave)

waveCopy :: Wave -> IO Wave

p'waveCopy :: FunPtr (Wave -> IO Wave)

c'waveCrop :: Ptr Wave -> CInt -> CInt -> IO ()

waveCrop :: Wave -> Int -> Int -> IO Wave

p'waveCrop :: FunPtr (Ptr Wave -> CInt -> CInt -> IO ())

c'waveFormat :: Ptr Wave -> CInt -> CInt -> CInt -> IO ()

waveFormat :: Wave -> Int -> Int -> Int -> IO ()

p'waveFormat :: FunPtr (Ptr Wave -> CInt -> CInt -> CInt -> IO ())

c'loadWaveSamples :: Ptr Wave -> IO (Ptr CFloat)

loadWaveSamples :: Wave -> IO [Float]

p'loadWaveSamples :: FunPtr (Wave -> IO (Ptr CFloat))

c'unloadWaveSamples :: Ptr CFloat -> IO ()

p'unloadWaveSamples :: FunPtr (Ptr CFloat -> IO ())

c'loadMusicStream :: CString -> IO (Ptr Music)

loadMusicStream :: String -> IO Music

p'loadMusicStream :: FunPtr (CString -> IO Music)

c'loadMusicStreamFromMemory :: CString -> Ptr CUChar -> CInt -> IO (Ptr Music)

loadMusicStreamFromMemory :: String -> [Integer] -> IO Music

p'loadMusicStreamFromMemory :: FunPtr (CString -> Ptr CUChar -> CInt -> IO Music)

c'unloadMusicStream :: Ptr Music -> IO ()

unloadMusicStream :: Music -> IO ()

p'unloadMusicStream :: FunPtr (Music -> IO ())

c'playMusicStream :: Ptr Music -> IO ()

playMusicStream :: Music -> IO ()

p'playMusicStream :: FunPtr (Music -> IO ())

c'isMusicStreamPlaying :: Ptr Music -> IO CInt

isMusicStreamPlaying :: Music -> IO Bool

p'isMusicStreamPlaying :: FunPtr (Music -> IO CInt)

c'updateMusicStream :: Ptr Music -> IO ()

updateMusicStream :: Music -> IO ()

p'updateMusicStream :: FunPtr (Music -> IO ())

c'stopMusicStream :: Ptr Music -> IO ()

stopMusicStream :: Music -> IO ()

p'stopMusicStream :: FunPtr (Music -> IO ())

c'pauseMusicStream :: Ptr Music -> IO ()

pauseMusicStream :: Music -> IO ()

p'pauseMusicStream :: FunPtr (Music -> IO ())

c'resumeMusicStream :: Ptr Music -> IO ()

resumeMusicStream :: Music -> IO ()

p'resumeMusicStream :: FunPtr (Music -> IO ())

c'seekMusicStream :: Ptr Music -> CFloat -> IO ()

seekMusicStream :: Music -> Float -> IO ()

p'seekMusicStream :: FunPtr (Music -> CFloat -> IO ())

c'setMusicVolume :: Ptr Music -> CFloat -> IO ()

setMusicVolume :: Music -> Float -> IO ()

p'setMusicVolume :: FunPtr (Music -> CFloat -> IO ())

c'setMusicPitch :: Ptr Music -> CFloat -> IO ()

setMusicPitch :: Music -> Float -> IO ()

p'setMusicPitch :: FunPtr (Music -> CFloat -> IO ())

c'setMusicPan :: Ptr Music -> CFloat -> IO ()

setMusicPan :: Music -> Float -> IO ()

p'setMusicPan :: FunPtr (Music -> CFloat -> IO ())

c'getMusicTimeLength :: Ptr Music -> IO CFloat

getMusicTimeLength :: Music -> IO Float

p'getMusicTimeLength :: FunPtr (Music -> IO CFloat)

c'getMusicTimePlayed :: Ptr Music -> IO CFloat

getMusicTimePlayed :: Music -> IO Float

p'getMusicTimePlayed :: FunPtr (Music -> IO CFloat)

c'loadAudioStream :: CUInt -> CUInt -> CUInt -> IO (Ptr AudioStream)

loadAudioStream :: Integer -> Integer -> Integer -> IO AudioStream

p'loadAudioStream :: FunPtr (CUInt -> CUInt -> CUInt -> IO AudioStream)

c'unloadAudioStream :: Ptr AudioStream -> IO ()

unloadAudioStream :: AudioStream -> IO ()

p'unloadAudioStream :: FunPtr (AudioStream -> IO ())

c'updateAudioStream :: Ptr AudioStream -> Ptr () -> CInt -> IO ()

updateAudioStream :: AudioStream -> Ptr () -> Int -> IO ()

p'updateAudioStream :: FunPtr (AudioStream -> Ptr () -> CInt -> IO ())

c'isAudioStreamProcessed :: Ptr AudioStream -> IO CInt

isAudioStreamProcessed :: AudioStream -> IO Bool

p'isAudioStreamProcessed :: FunPtr (AudioStream -> IO CInt)

c'playAudioStream :: Ptr AudioStream -> IO ()

playAudioStream :: AudioStream -> IO ()

p'playAudioStream :: FunPtr (AudioStream -> IO ())

c'pauseAudioStream :: Ptr AudioStream -> IO ()

pauseAudioStream :: AudioStream -> IO ()

p'pauseAudioStream :: FunPtr (AudioStream -> IO ())

c'resumeAudioStream :: Ptr AudioStream -> IO ()

resumeAudioStream :: AudioStream -> IO ()

p'resumeAudioStream :: FunPtr (AudioStream -> IO ())

c'isAudioStreamPlaying :: Ptr AudioStream -> IO CInt

isAudioStreamPlaying :: AudioStream -> IO Bool

p'isAudioStreamPlaying :: FunPtr (AudioStream -> IO CInt)

c'stopAudioStream :: Ptr AudioStream -> IO ()

stopAudioStream :: AudioStream -> IO ()

p'stopAudioStream :: FunPtr (AudioStream -> IO ())

c'setAudioStreamVolume :: Ptr AudioStream -> CFloat -> IO ()

setAudioStreamVolume :: AudioStream -> Float -> IO ()

p'setAudioStreamVolume :: FunPtr (AudioStream -> CFloat -> IO ())

c'setAudioStreamPitch :: Ptr AudioStream -> CFloat -> IO ()

setAudioStreamPitch :: AudioStream -> Float -> IO ()

p'setAudioStreamPitch :: FunPtr (AudioStream -> CFloat -> IO ())

c'setAudioStreamPan :: Ptr AudioStream -> CFloat -> IO ()

setAudioStreamPan :: AudioStream -> Float -> IO ()

p'setAudioStreamPan :: FunPtr (AudioStream -> CFloat -> IO ())

c'setAudioStreamBufferSizeDefault :: CInt -> IO ()

setAudioStreamBufferSizeDefault :: Int -> IO ()

p'setAudioStreamBufferSizeDefault :: FunPtr (CInt -> IO ())

c'setAudioStreamCallback :: Ptr AudioStream -> Ptr AudioCallback -> IO ()

p'setAudioStreamCallback :: FunPtr (AudioStream -> AudioCallback -> IO ())

c'attachAudioStreamProcessor :: Ptr AudioStream -> Ptr AudioCallback -> IO ()

p'attachAudioStreamProcessor :: FunPtr (AudioStream -> AudioCallback -> IO ())

c'detachAudioStreamProcessor :: Ptr AudioStream -> Ptr AudioCallback -> IO ()

p'detachAudioStreamProcessor :: FunPtr (AudioStream -> AudioCallback -> IO ())