{-# OPTIONS -Wall #-} module Raylib.Types where -- This file includes Haskell counterparts to the structs defined in raylib import Foreign.C ( CString, CChar, CUShort, CUInt, CInt, CUChar, CFloat, CBool ) import Foreign ( Ptr, plusPtr, pokeArray, peekArray, castPtr, Storable(pokeByteOff, poke, peek, alignment, sizeOf, peekByteOff) ) ------------------------------------------------ -- Raylib enumerations ------------------------- ------------------------------------------------ data ConfigFlag = VsyncHint | FullscreenMode | WindowResizable | WindowUndecorated | WindowHidden | WindowMinimized | WindowMaximized | WindowUnfocused | WindowTopmost | WindowAlwaysRun | WindowTransparent | WindowHighdpi | WindowMousePassthrough | Msaa4xHint | InterlacedHint deriving (Eq, Show) instance Enum ConfigFlag where fromEnum g = case g of VsyncHint -> 64 FullscreenMode -> 2 WindowResizable -> 4 WindowUndecorated -> 8 WindowHidden -> 128 WindowMinimized -> 512 WindowMaximized -> 1024 WindowUnfocused -> 2048 WindowTopmost -> 4096 WindowAlwaysRun -> 256 WindowTransparent -> 16 WindowHighdpi -> 8192 WindowMousePassthrough -> 16384 Msaa4xHint -> 32 InterlacedHint -> 65536 toEnum x = case x of 64 -> VsyncHint 2 -> FullscreenMode 4 -> WindowResizable 8 -> WindowUndecorated 128 -> WindowHidden 512 -> WindowMinimized 1024 -> WindowMaximized 2048 -> WindowUnfocused 4096 -> WindowTopmost 256 -> WindowAlwaysRun 16 -> WindowTransparent 8192 -> WindowHighdpi 16384 -> WindowMousePassthrough 32 -> Msaa4xHint 65536 -> InterlacedHint n -> error $ "Invalid value " ++ show n ++ " for `toEnum`." data TraceLogLevel = LogAll | LogTrace | LogDebug | LogInfo | LogWarning | LogError | LogFatal | LogNone deriving (Eq, Show,Enum) data KeyboardKey = KeyNull | KeyApostrophe | KeyComma | KeyMinus | KeyPeriod | KeySlash | KeyZero | KeyOne | KeyTwo | KeyThree | KeyFour | KeyFive | KeySix | KeySeven | KeyEight | KeyNine | KeySemicolon | KeyEqual | KeyA | KeyB | KeyC | KeyD | KeyE | KeyF | KeyG | KeyH | KeyI | KeyJ | KeyK | KeyL | KeyM | KeyN | KeyO | KeyP | KeyQ | KeyR | KeyS | KeyT | KeyU | KeyV | KeyW | KeyX | KeyY | KeyZ | KeyLeftBracket | KeyBackslash | KeyRightBracket | KeyGrave | KeySpace | KeyEscape | KeyEnter | KeyTab | KeyBackspace | KeyInsert | KeyDelete | KeyRight | KeyLeft | KeyDown | KeyUp | KeyPageUp | KeyPageDown | KeyHome | KeyEnd | KeyCapsLock | KeyScrollLock | KeyNumLock | KeyPrintScreen | KeyPause | KeyF1 | KeyF2 | KeyF3 | KeyF4 | KeyF5 | KeyF6 | KeyF7 | KeyF8 | KeyF9 | KeyF10 | KeyF11 | KeyF12 | KeyLeftShift | KeyLeftControl | KeyLeftAlt | KeyLeftSuper | KeyRightShift | KeyRightControl | KeyRightAlt | KeyRightSuper | KeyKbMenu | KeyKp0 | KeyKp1 | KeyKp2 | KeyKp3 | KeyKp4 | KeyKp5 | KeyKp6 | KeyKp7 | KeyKp8 | KeyKp9 | KeyKpDecimal | KeyKpDivide | KeyKpMultiply | KeyKpSubtract | KeyKpAdd | KeyKpEnter | KeyKpEqual | KeyBack | KeyMenu | KeyVolumeUp | KeyVolumeDown deriving (Eq, Show) instance Enum KeyboardKey where fromEnum k = case k of KeyNull -> 0 KeyApostrophe -> 39 KeyComma -> 44 KeyMinus -> 45 KeyPeriod -> 46 KeySlash -> 47 KeyZero -> 48 KeyOne -> 49 KeyTwo -> 50 KeyThree -> 51 KeyFour -> 52 KeyFive -> 53 KeySix -> 54 KeySeven -> 55 KeyEight -> 56 KeyNine -> 57 KeySemicolon -> 59 KeyEqual -> 61 KeyA -> 65 KeyB -> 66 KeyC -> 67 KeyD -> 68 KeyE -> 69 KeyF -> 70 KeyG -> 71 KeyH -> 72 KeyI -> 73 KeyJ -> 74 KeyK -> 75 KeyL -> 76 KeyM -> 77 KeyN -> 78 KeyO -> 79 KeyP -> 80 KeyQ -> 81 KeyR -> 82 KeyS -> 83 KeyT -> 84 KeyU -> 85 KeyV -> 86 KeyW -> 87 KeyX -> 88 KeyY -> 89 KeyZ -> 90 KeyLeftBracket -> 91 KeyBackslash -> 92 KeyRightBracket -> 93 KeyGrave -> 96 KeySpace -> 32 KeyEscape -> 256 KeyEnter -> 257 KeyTab -> 258 KeyBackspace -> 259 KeyInsert -> 260 KeyDelete -> 261 KeyRight -> 262 KeyLeft -> 263 KeyDown -> 264 KeyUp -> 265 KeyPageUp -> 266 KeyPageDown -> 267 KeyHome -> 268 KeyEnd -> 269 KeyCapsLock -> 280 KeyScrollLock -> 281 KeyNumLock -> 282 KeyPrintScreen -> 283 KeyPause -> 284 KeyF1 -> 290 KeyF2 -> 291 KeyF3 -> 292 KeyF4 -> 293 KeyF5 -> 294 KeyF6 -> 295 KeyF7 -> 296 KeyF8 -> 297 KeyF9 -> 298 KeyF10 -> 299 KeyF11 -> 300 KeyF12 -> 301 KeyLeftShift -> 340 KeyLeftControl -> 341 KeyLeftAlt -> 342 KeyLeftSuper -> 343 KeyRightShift -> 344 KeyRightControl -> 345 KeyRightAlt -> 346 KeyRightSuper -> 347 KeyKbMenu -> 348 KeyKp0 -> 320 KeyKp1 -> 321 KeyKp2 -> 322 KeyKp3 -> 323 KeyKp4 -> 324 KeyKp5 -> 325 KeyKp6 -> 326 KeyKp7 -> 327 KeyKp8 -> 328 KeyKp9 -> 329 KeyKpDecimal -> 330 KeyKpDivide -> 331 KeyKpMultiply -> 332 KeyKpSubtract -> 333 KeyKpAdd -> 334 KeyKpEnter -> 335 KeyKpEqual -> 336 -- Android buttons KeyBack -> 4 KeyMenu -> 82 KeyVolumeUp -> 24 KeyVolumeDown -> 25 toEnum n = case n of 0 -> KeyNull 39 -> KeyApostrophe 44 -> KeyComma 45 -> KeyMinus 46 -> KeyPeriod 47 -> KeySlash 48 -> KeyZero 49 -> KeyOne 50 -> KeyTwo 51 -> KeyThree 52 -> KeyFour 53 -> KeyFive 54 -> KeySix 55 -> KeySeven 56 -> KeyEight 57 -> KeyNine 59 -> KeySemicolon 61 -> KeyEqual 65 -> KeyA 66 -> KeyB 67 -> KeyC 68 -> KeyD 69 -> KeyE 70 -> KeyF 71 -> KeyG 72 -> KeyH 73 -> KeyI 74 -> KeyJ 75 -> KeyK 76 -> KeyL 77 -> KeyM 78 -> KeyN 79 -> KeyO 80 -> KeyP 81 -> KeyQ 82 -> KeyR 83 -> KeyS 84 -> KeyT 85 -> KeyU 86 -> KeyV 87 -> KeyW 88 -> KeyX 89 -> KeyY 90 -> KeyZ 91 -> KeyLeftBracket 92 -> KeyBackslash 93 -> KeyRightBracket 96 -> KeyGrave 32 -> KeySpace 256 -> KeyEscape 257 -> KeyEnter 258 -> KeyTab 259 -> KeyBackspace 260 -> KeyInsert 261 -> KeyDelete 262 -> KeyRight 263 -> KeyLeft 264 -> KeyDown 265 -> KeyUp 266 -> KeyPageUp 267 -> KeyPageDown 268 -> KeyHome 269 -> KeyEnd 280 -> KeyCapsLock 281 -> KeyScrollLock 282 -> KeyNumLock 283 -> KeyPrintScreen 284 -> KeyPause 290 -> KeyF1 291 -> KeyF2 292 -> KeyF3 293 -> KeyF4 294 -> KeyF5 295 -> KeyF6 296 -> KeyF7 297 -> KeyF8 298 -> KeyF9 299 -> KeyF10 300 -> KeyF11 301 -> KeyF12 340 -> KeyLeftShift 341 -> KeyLeftControl 342 -> KeyLeftAlt 343 -> KeyLeftSuper 344 -> KeyRightShift 345 -> KeyRightControl 346 -> KeyRightAlt 347 -> KeyRightSuper 348 -> KeyKbMenu 320 -> KeyKp0 321 -> KeyKp1 322 -> KeyKp2 323 -> KeyKp3 324 -> KeyKp4 325 -> KeyKp5 326 -> KeyKp6 327 -> KeyKp7 328 -> KeyKp8 329 -> KeyKp9 330 -> KeyKpDecimal 331 -> KeyKpDivide 332 -> KeyKpMultiply 333 -> KeyKpSubtract 334 -> KeyKpAdd 335 -> KeyKpEnter 336 -> KeyKpEqual -- Android buttons 4 -> KeyBack -- 82 -> KeyMenu 24 -> KeyVolumeUp 25 -> KeyVolumeDown x -> error $ "Invalid value " ++ show x ++ " for `fromEnum`." data MouseButton = MouseButtonLeft | MouseButtonRight | MouseButtonMiddle | MouseButtonSide | MouseButtonExtra | MouseButtonForward | MouseButtonBack deriving (Eq, Show, Enum) data MouseCursor = MouseCursorDefault | MouseCursorArrow | MouseCursorIbeam | MouseCursorCrosshair | MouseCursorPointingHand | MouseCursorResizeEW | MouseCursorResizeNS | MouseCursorResizeNWSE | MouseCursorResizeNESW | MouseCursorResizeAll | MouseCursorNotAllowed deriving (Eq, Show, Enum) data GamepadButton = GamepadButtonUnknown | GamepadButtonUnknownLeftFaceUp | GamepadButtonLeftFaceRight | GamepadButtonLeftFaceDown | GamepadButtonLeftFaceLeft | GamepadButtonRightFaceUp | GamepadButtonRightFaceRight | GamepadButtonRightFaceDown | GamepadButtonRightFaceLeft | GamepadButtonLeftTrigger1 | GamepadButtonLeftTrigger2 | GamepadButtonRightTrigger1 | GamepadButtonRightTrigger2 | GamepadButtonMiddleLeft | GamepadButtonMiddle | GamepadButtonMiddleRight | GamepadButtonLeftThumb | GamepadButtonRightThumb deriving (Eq, Show, Enum) data GamepadAxis = GamepadAxisLeftX | GamepadAxisLeftY | GamepadAxisRightX | GamepadAxisRightY | GamepadAxisLeftTrigger | GamepadAxisRightTrigger deriving (Eq, Show, Enum) data MaterialMapIndex = MaterialMapAlbedo | MaterialMapMetalness | MaterialMapNormal | MaterialMapRoughness | MaterialMapOcclusion | MaterialMapEmission | MaterialMapHeight | MaterialMapCubemap | MaterialMapIrradiance | MaterialMapPrefilter | MaterialMapBrdf deriving (Eq, Show, Enum) data ShaderLocationIndex = ShaderLocVertexPosition | ShaderLocVertexTexcoord01 | ShaderLocVertexTexcoord02 | ShaderLocVertexNormal | ShaderLocVertexTangent | ShaderLocVertexColor | ShaderLocMatrixMvp | ShaderLocMatrixView | ShaderLocMatrixProjection | ShaderLocMatrixModel | ShaderLocMatrixNormal | ShaderLocVectorView | ShaderLocColorDiffuse | ShaderLocColorSpecular | ShaderLocColorAmbient | ShaderLocMapAlbedo | ShaderLocMapMetalness | ShaderLocMapNormal | ShaderLocMapRoughness | ShaderLocMapOcclusion | ShaderLocMapEmission | ShaderLocMapHeight | ShaderLocMapCubemap | ShaderLocMapIrradiance | ShaderLocMapPrefilter | ShaderLocMapBrdf deriving (Eq, Show, Enum) data ShaderUniformDataType = ShaderUniformFloat | ShaderUniformVec2 | ShaderUniformVec3 | ShaderUniformVec4 | ShaderUniformInt | ShaderUniformIvec2 | ShaderUniformIvec3 | ShaderUniformIvec4 | ShaderUniformSampler2d deriving (Eq, Show, Enum) -- I genuinely have no idea where this is used. data ShaderAttributeDataType = ShaderAttribFloat | ShaderAttribVec2 | ShaderAttribVec3 | ShaderAttribVec4 deriving (Eq, Show, Enum) data PixelFormat = PixelFormatUncompressedGrayscale | PixelFormatUncompressedGrayAlpha | PixelFormatUncompressedR5G6B5 | PixelFormatUncompressedR8G8B8 | PixelFormatUncompressedR5G5B5A1 | PixelFormatUncompressedR4G4B4A4 | PixelFormatUncompressedR8G8B8A8 | PixelFormatUncompressedR32 | PixelFormatUncompressedR32G32B32 | PixelFormatUncompressedR32G32B32A32 | PixelFormatCompressedDxt1Rgb | PixelFormatCompressedDxt1Rgba | PixelFormatCompressedDxt3Rgba | PixelFormatCompressedDxt5Rgba | PixelFormatCompressedEtc1Rgb | PixelFormatCompressedEtc2Rgb | PixelFormatCompressedEtc2EacRgba | PixelFormatCompressedPvrtRgb | PixelFormatCompressedPvrtRgba | PixelFormatCompressedAstc4x4Rgba | PixelFormatCompressedAstc8x8Rgba deriving (Eq, Show, Enum) instance Storable PixelFormat where sizeOf _ = 4 alignment _ = 4 peek ptr = do val <- peek (castPtr ptr) return $ toEnum $ fromEnum (val :: CInt) poke ptr v = poke (castPtr ptr) (toEnum $ fromEnum v :: CInt) data TextureFilter = TextureFilterPoint | TextureFilterBilinear | TextureFilterTrilinear | TextureFilterAnisotropic4x | TextureFilterAnisotropic8x | TextureFilterAnisotropic16x deriving Enum data TextureWrap = TextureWrapRepeat | TextureWrapClamp | TextureWrapMirrorRepeat | TextureWrapMirrorClamp deriving Enum data CubemapLayout = CubemapLayoutAutoDetect | CubemapLayoutLineVertical | CubemapLayoutLineHorizontal | CubemapLayoutCrossThreeByFour | CubemapLayoutCrossThreeByThree | CubemapLayoutPanorama deriving Enum data FontType = FontDefault | FontBitmap | FontSDF deriving Enum data BlendMode = BlendAlpha | BlendAdditive | BlendMultiplied | BlendAddColors | BlendSubtractColors | BlendAlphaPremultiply | BlendCustom | BlendCustomSeparate deriving Enum data Gesture = GestureNone | GestureTap | GestureDoubleTap | GestureHold | GestureDrag | GestureSwipeRight | GestureSwipeLeft | GestureSwipeUp | GestureSwipeDown | GesturePinchIn | GesturePinchOut deriving (Show) -- NOTE: This is not the ideal solution, I need to make this unjanky instance Enum Gesture where fromEnum n = case n of GestureNone -> 0 GestureTap -> 1 GestureDoubleTap -> 2 GestureHold -> 4 GestureDrag -> 8 GestureSwipeRight -> 16 GestureSwipeLeft -> 32 GestureSwipeUp -> 64 GestureSwipeDown -> 128 GesturePinchIn -> 256 GesturePinchOut -> 512 toEnum n = case n of 0 -> GestureNone 1 -> GestureTap 2 -> GestureDoubleTap 4 -> GestureHold 8 -> GestureDrag 16 -> GestureSwipeRight 32 -> GestureSwipeLeft 64 -> GestureSwipeUp 128 -> GestureSwipeDown 256 -> GesturePinchIn 512 -> GesturePinchOut _ -> error "Invalid input" data CameraMode = CameraModeCustom | CameraModeFree | CameraModeOrbital | CameraModeFirstPerson | CameraModeThirdPerson deriving (Enum) data CameraProjection = CameraPerspective | CameraOrthographic deriving (Eq, Show, Enum) instance Storable CameraProjection where sizeOf _ = 4 alignment _ = 4 peek ptr = do val <- peek (castPtr ptr) return $ toEnum $ fromEnum (val :: CInt) poke ptr v = poke (castPtr ptr) (toEnum $ fromEnum v :: CInt) data NPatchLayout = NPatchNinePatch | NPatchThreePatchVertical | NPatchThreePatchHorizontal deriving (Eq, Show, Enum) instance Storable NPatchLayout where sizeOf _ = 4 alignment _ = 4 peek ptr = do val <- peek (castPtr ptr) return $ toEnum $ fromEnum (val :: CInt) poke ptr v = poke (castPtr ptr) (toEnum $ fromEnum v :: CInt) ------------------------------------------------ -- Raylib structures --------------------------- ------------------------------------------------ {- typedef struct Vector2 { float x; float y; } Vector2; -} data Vector2 = Vector2 { vector2'x :: CFloat, vector2'y :: CFloat } deriving (Eq, Show) p'Vector2'x p = plusPtr p 0 p'Vector2'x :: Ptr Vector2 -> Ptr CFloat p'Vector2'y p = plusPtr p 4 p'Vector2'y :: Ptr Vector2 -> Ptr CFloat instance Storable Vector2 where sizeOf _ = 8 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 return $ Vector2 v0 v1 poke _p (Vector2 v0 v1) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 return () {- typedef struct Vector3 { float x; float y; float z; } Vector3; -} data Vector3 = Vector3 { vector3'x :: CFloat, vector3'y :: CFloat, vector3'z :: CFloat } deriving (Eq, Show) p'Vector3'x p = plusPtr p 0 p'Vector3'x :: Ptr Vector3 -> Ptr CFloat p'Vector3'y p = plusPtr p 4 p'Vector3'y :: Ptr Vector3 -> Ptr CFloat p'Vector3'z p = plusPtr p 8 p'Vector3'z :: Ptr Vector3 -> Ptr CFloat instance Storable Vector3 where sizeOf _ = 12 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 return $ Vector3 v0 v1 v2 poke _p (Vector3 v0 v1 v2) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 return () {- typedef struct Vector4 { float x; float y; float z; float w; } Vector4; -} data Vector4 = Vector4 { vector4'x :: CFloat, vector4'y :: CFloat, vector4'z :: CFloat, vector4'w :: CFloat } deriving (Eq, Show) p'Vector4'x p = plusPtr p 0 p'Vector4'x :: Ptr Vector4 -> Ptr CFloat p'Vector4'y p = plusPtr p 4 p'Vector4'y :: Ptr Vector4 -> Ptr CFloat p'Vector4'z p = plusPtr p 8 p'Vector4'z :: Ptr Vector4 -> Ptr CFloat p'Vector4'w p = plusPtr p 12 p'Vector4'w :: Ptr Vector4 -> Ptr CFloat instance Storable Vector4 where sizeOf _ = 16 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 return $ Vector4 v0 v1 v2 v3 poke _p (Vector4 v0 v1 v2 v3) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 return () {- typedef Vector4 Quaternion; -} type Quaternion = Vector4 {- typedef struct Matrix { float m0, m4, m8, m12; float m1, m5, m9, m13; float m2, m6, m10, m14; float m3, m7, m11, m15; } Matrix; -} data Matrix = Matrix { matrix'm0 :: CFloat, matrix'm4 :: CFloat, matrix'm8 :: CFloat, matrix'm12 :: CFloat, matrix'm1 :: CFloat, matrix'm5 :: CFloat, matrix'm9 :: CFloat, matrix'm13 :: CFloat, matrix'm2 :: CFloat, matrix'm6 :: CFloat, matrix'm10 :: CFloat, matrix'm14 :: CFloat, matrix'm3 :: CFloat, matrix'm7 :: CFloat, matrix'm11 :: CFloat, matrix'm15 :: CFloat } deriving (Eq, Show) p'Matrix'm0 p = plusPtr p 0 p'Matrix'm0 :: Ptr Matrix -> Ptr CFloat p'Matrix'm4 p = plusPtr p 4 p'Matrix'm4 :: Ptr Matrix -> Ptr CFloat p'Matrix'm8 p = plusPtr p 8 p'Matrix'm8 :: Ptr Matrix -> Ptr CFloat p'Matrix'm12 p = plusPtr p 12 p'Matrix'm12 :: Ptr Matrix -> Ptr CFloat p'Matrix'm1 p = plusPtr p 16 p'Matrix'm1 :: Ptr Matrix -> Ptr CFloat p'Matrix'm5 p = plusPtr p 20 p'Matrix'm5 :: Ptr Matrix -> Ptr CFloat p'Matrix'm9 p = plusPtr p 24 p'Matrix'm9 :: Ptr Matrix -> Ptr CFloat p'Matrix'm13 p = plusPtr p 28 p'Matrix'm13 :: Ptr Matrix -> Ptr CFloat p'Matrix'm2 p = plusPtr p 32 p'Matrix'm2 :: Ptr Matrix -> Ptr CFloat p'Matrix'm6 p = plusPtr p 36 p'Matrix'm6 :: Ptr Matrix -> Ptr CFloat p'Matrix'm10 p = plusPtr p 40 p'Matrix'm10 :: Ptr Matrix -> Ptr CFloat p'Matrix'm14 p = plusPtr p 44 p'Matrix'm14 :: Ptr Matrix -> Ptr CFloat p'Matrix'm3 p = plusPtr p 48 p'Matrix'm3 :: Ptr Matrix -> Ptr CFloat p'Matrix'm7 p = plusPtr p 52 p'Matrix'm7 :: Ptr Matrix -> Ptr CFloat p'Matrix'm11 p = plusPtr p 56 p'Matrix'm11 :: Ptr Matrix -> Ptr CFloat p'Matrix'm15 p = plusPtr p 60 p'Matrix'm15 :: Ptr Matrix -> Ptr CFloat instance Storable Matrix where sizeOf _ = 64 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 v5 <- peekByteOff _p 20 v6 <- peekByteOff _p 24 v7 <- peekByteOff _p 28 v8 <- peekByteOff _p 32 v9 <- peekByteOff _p 36 v10 <- peekByteOff _p 40 v11 <- peekByteOff _p 44 v12 <- peekByteOff _p 48 v13 <- peekByteOff _p 52 v14 <- peekByteOff _p 56 v15 <- peekByteOff _p 60 return $ Matrix v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15 poke _p (Matrix v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 v15) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 pokeByteOff _p 20 v5 pokeByteOff _p 24 v6 pokeByteOff _p 28 v7 pokeByteOff _p 32 v8 pokeByteOff _p 36 v9 pokeByteOff _p 40 v10 pokeByteOff _p 44 v11 pokeByteOff _p 48 v12 pokeByteOff _p 52 v13 pokeByteOff _p 56 v14 pokeByteOff _p 60 v15 return () {- typedef struct Color { unsigned char r; unsigned char g; unsigned char b; unsigned char a; } Color; -} data Color = Color { color'r :: CUChar, color'g :: CUChar, color'b :: CUChar, color'a :: CUChar } deriving (Eq, Show) p'Color'r p = plusPtr p 0 p'Color'r :: Ptr Color -> Ptr CUChar p'Color'g p = plusPtr p 1 p'Color'g :: Ptr Color -> Ptr CUChar p'Color'b p = plusPtr p 2 p'Color'b :: Ptr Color -> Ptr CUChar p'Color'a p = plusPtr p 3 p'Color'a :: Ptr Color -> Ptr CUChar instance Storable Color where sizeOf _ = 4 alignment _ = 1 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 1 v2 <- peekByteOff _p 2 v3 <- peekByteOff _p 3 return $ Color v0 v1 v2 v3 poke _p (Color v0 v1 v2 v3) = do pokeByteOff _p 0 v0 pokeByteOff _p 1 v1 pokeByteOff _p 2 v2 pokeByteOff _p 3 v3 return () {- typedef struct Rectangle { float x; float y; float width; float height; } Rectangle; -} data Rectangle = Rectangle { rectangle'x :: CFloat, rectangle'y :: CFloat, rectangle'width :: CFloat, rectangle'height :: CFloat } deriving (Eq, Show) p'Rectangle'x p = plusPtr p 0 p'Rectangle'x :: Ptr Rectangle -> Ptr CFloat p'Rectangle'y p = plusPtr p 4 p'Rectangle'y :: Ptr Rectangle -> Ptr CFloat p'Rectangle'width p = plusPtr p 8 p'Rectangle'width :: Ptr Rectangle -> Ptr CFloat p'Rectangle'height p = plusPtr p 12 p'Rectangle'height :: Ptr Rectangle -> Ptr CFloat instance Storable Rectangle where sizeOf _ = 16 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 return $ Rectangle v0 v1 v2 v3 poke _p (Rectangle v0 v1 v2 v3) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 return () {- typedef struct Image { void * data; int width; int height; int mipmaps; int format; } Image; -} data Image = Image { image'data :: Ptr (), image'width :: CInt, image'height :: CInt, image'mipmaps :: CInt, image'format :: PixelFormat } deriving (Eq, Show) p'Image'data p = plusPtr p 0 p'Image'data :: Ptr Image -> Ptr (Ptr ()) p'Image'width p = plusPtr p 4 p'Image'width :: Ptr Image -> Ptr CInt p'Image'height p = plusPtr p 8 p'Image'height :: Ptr Image -> Ptr CInt p'Image'mipmaps p = plusPtr p 12 p'Image'mipmaps :: Ptr Image -> Ptr CInt p'Image'format p = plusPtr p 16 p'Image'format :: Ptr Image -> Ptr CInt instance Storable Image where sizeOf _ = 20 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 return $ Image v0 v1 v2 v3 v4 poke _p (Image v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 return () {- typedef struct Texture { unsigned int id; int width; int height; int mipmaps; int format; } Texture; -} data Texture = Texture { texture'id :: CUInt, texture'width :: CInt, texture'height :: CInt, texture'mipmaps :: CInt, texture'format :: PixelFormat } deriving (Eq, Show) p'Texture'id p = plusPtr p 0 p'Texture'id :: Ptr Texture -> Ptr CUInt p'Texture'width p = plusPtr p 4 p'Texture'width :: Ptr Texture -> Ptr CInt p'Texture'height p = plusPtr p 8 p'Texture'height :: Ptr Texture -> Ptr CInt p'Texture'mipmaps p = plusPtr p 12 p'Texture'mipmaps :: Ptr Texture -> Ptr CInt p'Texture'format p = plusPtr p 16 p'Texture'format :: Ptr Texture -> Ptr CInt instance Storable Texture where sizeOf _ = 20 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 return $ Texture v0 v1 v2 v3 v4 poke _p (Texture v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 return () {- typedef Texture Texture2D; -} type Texture2D = Texture {- typedef Texture TextureCubemap; -} type TextureCubemap = Texture {- typedef struct RenderTexture { unsigned int id; Texture texture; Texture depth; } RenderTexture; -} data RenderTexture = RenderTexture { rendertexture'id :: CUInt, rendertexture'texture :: Texture, rendertexture'depth :: Texture } deriving (Eq, Show) p'RenderTexture'id p = plusPtr p 0 p'RenderTexture'id :: Ptr RenderTexture -> Ptr CUInt p'RenderTexture'texture p = plusPtr p 4 p'RenderTexture'texture :: Ptr RenderTexture -> Ptr Texture p'RenderTexture'depth p = plusPtr p 24 p'RenderTexture'depth :: Ptr RenderTexture -> Ptr Texture instance Storable RenderTexture where sizeOf _ = 44 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 24 return $ RenderTexture v0 v1 v2 poke _p (RenderTexture v0 v1 v2) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 24 v2 return () {- typedef RenderTexture RenderTexture2D; -} type RenderTexture2D = RenderTexture {- typedef struct NPatchInfo { Rectangle source; int left; int top; int right; int bottom; int layout; } NPatchInfo; -} data NPatchInfo = NPatchInfo { nPatchinfo'source :: Rectangle, nPatchinfo'left :: CInt, nPatchinfo'top :: CInt, nPatchinfo'right :: CInt, nPatchinfo'bottom :: CInt, nPatchinfo'layout :: NPatchLayout } deriving (Eq, Show) p'NPatchInfo'source p = plusPtr p 0 p'NPatchInfo'source :: Ptr NPatchInfo -> Ptr Rectangle p'NPatchInfo'left p = plusPtr p 16 p'NPatchInfo'left :: Ptr NPatchInfo -> Ptr CInt p'NPatchInfo'top p = plusPtr p 20 p'NPatchInfo'top :: Ptr NPatchInfo -> Ptr CInt p'NPatchInfo'right p = plusPtr p 24 p'NPatchInfo'right :: Ptr NPatchInfo -> Ptr CInt p'NPatchInfo'bottom p = plusPtr p 28 p'NPatchInfo'bottom :: Ptr NPatchInfo -> Ptr CInt p'NPatchInfo'layout p = plusPtr p 32 p'NPatchInfo'layout :: Ptr NPatchInfo -> Ptr CInt instance Storable NPatchInfo where sizeOf _ = 36 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 16 v2 <- peekByteOff _p 20 v3 <- peekByteOff _p 24 v4 <- peekByteOff _p 28 v5 <- peekByteOff _p 32 return $ NPatchInfo v0 v1 v2 v3 v4 v5 poke _p (NPatchInfo v0 v1 v2 v3 v4 v5) = do pokeByteOff _p 0 v0 pokeByteOff _p 16 v1 pokeByteOff _p 20 v2 pokeByteOff _p 24 v3 pokeByteOff _p 28 v4 pokeByteOff _p 32 v5 return () {- typedef struct GlyphInfo { int value; int offsetX; int offsetY; int advanceX; Image image; } GlyphInfo; -} data GlyphInfo = GlyphInfo { glyphinfo'value :: CInt, glyphInfo'offsetX :: CInt, glyphInfo'offsetY :: CInt, glyphInfo'advanceX :: CInt, glyphinfo'image :: Image } deriving (Eq, Show) p'GlyphInfo'value p = plusPtr p 0 p'GlyphInfo'value :: Ptr GlyphInfo -> Ptr CInt p'GlyphInfo'offsetX p = plusPtr p 4 p'GlyphInfo'offsetX :: Ptr GlyphInfo -> Ptr CInt p'GlyphInfo'offsetY p = plusPtr p 8 p'GlyphInfo'offsetY :: Ptr GlyphInfo -> Ptr CInt p'GlyphInfo'advanceX p = plusPtr p 12 p'GlyphInfo'advanceX :: Ptr GlyphInfo -> Ptr CInt p'GlyphInfo'image p = plusPtr p 16 p'GlyphInfo'image :: Ptr GlyphInfo -> Ptr Image instance Storable GlyphInfo where sizeOf _ = 36 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 return $ GlyphInfo v0 v1 v2 v3 v4 poke _p (GlyphInfo v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 return () {- typedef struct Font { int baseSize; int glyphCount; int glyphPadding; Texture2D texture; Rectangle * recs; GlyphInfo * glyphs; } Font; -} data Font = Font { font'baseSize :: CInt, font'glyphCount :: CInt, font'glyphPadding :: CInt, font'texture :: Texture, font'recs :: Ptr Rectangle, font'glyphs :: Ptr GlyphInfo } deriving (Eq, Show) p'Font'baseSize p = plusPtr p 0 p'Font'baseSize :: Ptr Font -> Ptr CInt p'Font'glyphCount p = plusPtr p 4 p'Font'glyphCount :: Ptr Font -> Ptr CInt p'Font'glyphPadding p = plusPtr p 8 p'Font'glyphPadding :: Ptr Font -> Ptr CInt p'Font'texture p = plusPtr p 12 p'Font'texture :: Ptr Font -> Ptr Texture p'Font'recs p = plusPtr p 32 p'Font'recs :: Ptr Font -> Ptr (Ptr Rectangle) p'Font'glyphs p = plusPtr p 40 p'Font'glyphs :: Ptr Font -> Ptr (Ptr GlyphInfo) instance Storable Font where sizeOf _ = 48 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 32 v5 <- peekByteOff _p 40 return $ Font v0 v1 v2 v3 v4 v5 poke _p (Font v0 v1 v2 v3 v4 v5) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 32 v4 pokeByteOff _p 40 v5 return () {- typedef struct Camera3D { Vector3 position; Vector3 target; Vector3 up; float fovy; int projection; } Camera3D; -} data Camera3D = Camera3D { camera3D'position :: Vector3, camera3D'target :: Vector3, camera3D'up :: Vector3, camera3D'fovy :: CFloat, camera3D'projection :: CameraProjection } deriving (Eq, Show) p'Camera3D'position p = plusPtr p 0 p'Camera3D'position :: Ptr Camera3D -> Ptr Vector3 p'Camera3D'target p = plusPtr p 12 p'Camera3D'target :: Ptr Camera3D -> Ptr Vector3 p'Camera3D'up p = plusPtr p 24 p'Camera3D'up :: Ptr Camera3D -> Ptr Vector3 p'Camera3D'fovy p = plusPtr p 36 p'Camera3D'fovy :: Ptr Camera3D -> Ptr CFloat p'Camera3D'projection p = plusPtr p 40 p'Camera3D'projection :: Ptr Camera3D -> Ptr CInt instance Storable Camera3D where sizeOf _ = 44 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 12 v2 <- peekByteOff _p 24 v3 <- peekByteOff _p 36 v4 <- peekByteOff _p 40 return $ Camera3D v0 v1 v2 v3 v4 poke _p (Camera3D v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 12 v1 pokeByteOff _p 24 v2 pokeByteOff _p 36 v3 pokeByteOff _p 40 v4 return () {- typedef Camera3D Camera; -} type Camera = Camera3D {- typedef struct Camera2D { Vector2 offset; Vector2 target; float rotation; float zoom; } Camera2D; -} data Camera2D = Camera2D { camera2D'offset :: Vector2, camera2D'target :: Vector2, camera2d'rotation :: CFloat, camera2d'zoom :: CFloat } deriving (Eq, Show) p'Camera2D'offset p = plusPtr p 0 p'Camera2D'offset :: Ptr Camera2D -> Ptr Vector2 p'Camera2D'target p = plusPtr p 8 p'Camera2D'target :: Ptr Camera2D -> Ptr Vector2 p'Camera2D'rotation p = plusPtr p 16 p'Camera2D'rotation :: Ptr Camera2D -> Ptr CFloat p'Camera2D'zoom p = plusPtr p 20 p'Camera2D'zoom :: Ptr Camera2D -> Ptr CFloat instance Storable Camera2D where sizeOf _ = 24 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 8 v2 <- peekByteOff _p 16 v3 <- peekByteOff _p 20 return $ Camera2D v0 v1 v2 v3 poke _p (Camera2D v0 v1 v2 v3) = do pokeByteOff _p 0 v0 pokeByteOff _p 8 v1 pokeByteOff _p 16 v2 pokeByteOff _p 20 v3 return () {- typedef struct Mesh { int vertexCount; int triangleCount; float * vertices; float * texcoords; float * texcoords2; float * normals; float * tangents; unsigned char * colors; unsigned short * indices; float * animVertices; float * animNormals; unsigned char * boneIds; float * boneWeights; unsigned int vaoId; unsigned int * vboId; } Mesh; -} data Mesh = Mesh { mesh'vertexCount :: CInt, mesh'triangleCount :: CInt, mesh'vertices :: Ptr CFloat, mesh'texcoords :: Ptr CFloat, mesh'texcoords2 :: Ptr CFloat, mesh'normals :: Ptr CFloat, mesh'tangents :: Ptr CFloat, mesh'colors :: Ptr CUChar, mesh'indices :: Ptr CUShort, mesh'animVertices :: Ptr CFloat, mesh'animNormals :: Ptr CFloat, mesh'boneIds :: Ptr CUChar, mesh'boneWeights :: Ptr CFloat, mesh'vaoId :: CUInt, mesh'vboId :: Ptr CUInt } deriving (Eq, Show) p'Mesh'vertexCount p = plusPtr p 0 p'Mesh'vertexCount :: Ptr Mesh -> Ptr CInt p'Mesh'triangleCount p = plusPtr p 4 p'Mesh'triangleCount :: Ptr Mesh -> Ptr CInt p'Mesh'vertices p = plusPtr p 8 p'Mesh'vertices :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'texcoords p = plusPtr p 12 p'Mesh'texcoords :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'texcoords2 p = plusPtr p 16 p'Mesh'texcoords2 :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'normals p = plusPtr p 20 p'Mesh'normals :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'tangents p = plusPtr p 24 p'Mesh'tangents :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'colors p = plusPtr p 28 p'Mesh'colors :: Ptr Mesh -> Ptr (Ptr CUChar) p'Mesh'indices p = plusPtr p 32 p'Mesh'indices :: Ptr Mesh -> Ptr (Ptr CUShort) p'Mesh'animVertices p = plusPtr p 36 p'Mesh'animVertices :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'animNormals p = plusPtr p 40 p'Mesh'animNormals :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'boneIds p = plusPtr p 44 p'Mesh'boneIds :: Ptr Mesh -> Ptr (Ptr CUChar) p'Mesh'boneWeights p = plusPtr p 48 p'Mesh'boneWeights :: Ptr Mesh -> Ptr (Ptr CFloat) p'Mesh'vaoId p = plusPtr p 52 p'Mesh'vaoId :: Ptr Mesh -> Ptr CUInt p'Mesh'vboId p = plusPtr p 56 p'Mesh'vboId :: Ptr Mesh -> Ptr (Ptr CUInt) instance Storable Mesh where sizeOf _ = 60 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 v5 <- peekByteOff _p 20 v6 <- peekByteOff _p 24 v7 <- peekByteOff _p 28 v8 <- peekByteOff _p 32 v9 <- peekByteOff _p 36 v10 <- peekByteOff _p 40 v11 <- peekByteOff _p 44 v12 <- peekByteOff _p 48 v13 <- peekByteOff _p 52 v14 <- peekByteOff _p 56 return $ Mesh v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14 poke _p (Mesh v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 v10 v11 v12 v13 v14) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 pokeByteOff _p 20 v5 pokeByteOff _p 24 v6 pokeByteOff _p 28 v7 pokeByteOff _p 32 v8 pokeByteOff _p 36 v9 pokeByteOff _p 40 v10 pokeByteOff _p 44 v11 pokeByteOff _p 48 v12 pokeByteOff _p 52 v13 pokeByteOff _p 56 v14 return () {- typedef struct Shader { unsigned int id; int * locs; } Shader; -} data Shader = Shader { shader'id :: CUInt, shader'locs :: Ptr CInt } deriving (Eq, Show) p'Shader'id p = plusPtr p 0 p'Shader'id :: Ptr Shader -> Ptr CUInt p'Shader'locs p = plusPtr p 4 p'Shader'locs :: Ptr Shader -> Ptr (Ptr CInt) instance Storable Shader where sizeOf _ = 8 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 return $ Shader v0 v1 poke _p (Shader v0 v1) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 return () {- typedef struct MaterialMap { Texture2D texture; Color color; float value; } MaterialMap; -} data MaterialMap = MaterialMap { materialmap'texture :: Texture, materialmap'color :: Color, materialmap'value :: CFloat } deriving (Eq, Show) p'MaterialMap'texture p = plusPtr p 0 p'MaterialMap'texture :: Ptr MaterialMap -> Ptr Texture p'MaterialMap'color p = plusPtr p 20 p'MaterialMap'color :: Ptr MaterialMap -> Ptr Color p'MaterialMap'value p = plusPtr p 24 p'MaterialMap'value :: Ptr MaterialMap -> Ptr CFloat instance Storable MaterialMap where sizeOf _ = 28 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 20 v2 <- peekByteOff _p 24 return $ MaterialMap v0 v1 v2 poke _p (MaterialMap v0 v1 v2) = do pokeByteOff _p 0 v0 pokeByteOff _p 20 v1 pokeByteOff _p 24 v2 return () {- typedef struct Material { Shader shader; MaterialMap * maps; float params[4]; } Material; -} data Material = Material { material'shader :: Shader, material'maps :: Ptr MaterialMap, material'params :: [CFloat] } deriving (Eq, Show) p'Material'shader p = plusPtr p 0 p'Material'shader :: Ptr Material -> Ptr Shader p'Material'maps p = plusPtr p 8 p'Material'maps :: Ptr Material -> Ptr (Ptr MaterialMap) p'Material'params p = plusPtr p 12 p'Material'params :: Ptr Material -> Ptr CFloat instance Storable Material where sizeOf _ = 28 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 8 v2 <- let s2 = div 16 $ sizeOf (undefined :: CFloat) in peekArray s2 (plusPtr _p 12) return $ Material v0 v1 v2 poke _p (Material v0 v1 v2) = do pokeByteOff _p 0 v0 pokeByteOff _p 8 v1 let s2 = div 16 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 12) (take s2 v2) return () {- typedef struct Transform { Vector3 translation; Quaternion rotation; Vector3 scale; } Transform; -} data Transform = Transform { transform'translation :: Vector3, transform'rotation :: Vector4, transform'scale :: Vector3 } deriving (Eq, Show) p'Transform'translation p = plusPtr p 0 p'Transform'translation :: Ptr Transform -> Ptr Vector3 p'Transform'rotation p = plusPtr p 12 p'Transform'rotation :: Ptr Transform -> Ptr Vector4 p'Transform'scale p = plusPtr p 28 p'Transform'scale :: Ptr Transform -> Ptr Vector3 instance Storable Transform where sizeOf _ = 40 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 12 v2 <- peekByteOff _p 28 return $ Transform v0 v1 v2 poke _p (Transform v0 v1 v2) = do pokeByteOff _p 0 v0 pokeByteOff _p 12 v1 pokeByteOff _p 28 v2 return () {- typedef struct BoneInfo { char name[32]; int parent; } BoneInfo; -} data BoneInfo = BoneInfo { boneInfo'name :: [CChar], boneinfo'parent :: CInt } deriving (Eq, Show) p'BoneInfo'name p = plusPtr p 0 p'BoneInfo'name :: Ptr BoneInfo -> Ptr CChar p'BoneInfo'parent p = plusPtr p 32 p'BoneInfo'parent :: Ptr BoneInfo -> Ptr CInt instance Storable BoneInfo where sizeOf _ = 36 alignment _ = 4 peek _p = do v0 <- let s0 = div 32 $ sizeOf (undefined :: CChar) in peekArray s0 (plusPtr _p 0) v1 <- peekByteOff _p 32 return $ BoneInfo v0 v1 poke _p (BoneInfo v0 v1) = do let s0 = div 32 $ sizeOf (undefined :: CChar) pokeArray (plusPtr _p 0) (take s0 v0) pokeByteOff _p 32 v1 return () {- typedef struct Model { Matrix transform; int meshCount; int materialCount; Mesh * meshes; Material * materials; int * meshMaterial; int boneCount; BoneInfo * bones; Transform * bindPose; } Model; -} data Model = Model { model'transform :: Matrix, model'meshCount :: CInt, model'materialCount :: CInt, model'meshes :: Ptr Mesh, model'materials :: Ptr Material, model'meshMaterial :: Ptr CInt, model'boneCount :: CInt, model'bones :: Ptr BoneInfo, model'bindPose :: Ptr Transform } deriving (Eq, Show) p'Model'transform p = plusPtr p 0 p'Model'transform :: Ptr Model -> Ptr Matrix p'Model'meshCount p = plusPtr p 64 p'Model'meshCount :: Ptr Model -> Ptr CInt p'Model'materialCount p = plusPtr p 68 p'Model'materialCount :: Ptr Model -> Ptr CInt p'Model'meshes p = plusPtr p 72 p'Model'meshes :: Ptr Model -> Ptr (Ptr Mesh) p'Model'materials p = plusPtr p 76 p'Model'materials :: Ptr Model -> Ptr (Ptr Material) p'Model'meshMaterial p = plusPtr p 80 p'Model'meshMaterial :: Ptr Model -> Ptr (Ptr CInt) p'Model'boneCount p = plusPtr p 84 p'Model'boneCount :: Ptr Model -> Ptr CInt p'Model'bones p = plusPtr p 88 p'Model'bones :: Ptr Model -> Ptr (Ptr BoneInfo) p'Model'bindPose p = plusPtr p 92 p'Model'bindPose :: Ptr Model -> Ptr (Ptr Transform) instance Storable Model where sizeOf _ = 96 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 64 v2 <- peekByteOff _p 68 v3 <- peekByteOff _p 72 v4 <- peekByteOff _p 76 v5 <- peekByteOff _p 80 v6 <- peekByteOff _p 84 v7 <- peekByteOff _p 88 v8 <- peekByteOff _p 92 return $ Model v0 v1 v2 v3 v4 v5 v6 v7 v8 poke _p (Model v0 v1 v2 v3 v4 v5 v6 v7 v8) = do pokeByteOff _p 0 v0 pokeByteOff _p 64 v1 pokeByteOff _p 68 v2 pokeByteOff _p 72 v3 pokeByteOff _p 76 v4 pokeByteOff _p 80 v5 pokeByteOff _p 84 v6 pokeByteOff _p 88 v7 pokeByteOff _p 92 v8 return () {- typedef struct ModelAnimation { int boneCount; int frameCount; BoneInfo * bones; Transform * * framePoses; } ModelAnimation; -} data ModelAnimation = ModelAnimation { modelAnimation'boneCount :: CInt, modelAnimation'frameCount :: CInt, modelAnimation'bones :: Ptr BoneInfo, modelAnimation'framePoses :: Ptr (Ptr Transform) } deriving (Eq, Show) p'ModelAnimation'boneCount p = plusPtr p 0 p'ModelAnimation'boneCount :: Ptr ModelAnimation -> Ptr CInt p'ModelAnimation'frameCount p = plusPtr p 4 p'ModelAnimation'frameCount :: Ptr ModelAnimation -> Ptr CInt p'ModelAnimation'bones p = plusPtr p 8 p'ModelAnimation'bones :: Ptr ModelAnimation -> Ptr (Ptr BoneInfo) p'ModelAnimation'framePoses p = plusPtr p 12 p'ModelAnimation'framePoses :: Ptr ModelAnimation -> Ptr (Ptr (Ptr Transform)) instance Storable ModelAnimation where sizeOf _ = 16 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 return $ ModelAnimation v0 v1 v2 v3 poke _p (ModelAnimation v0 v1 v2 v3) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 return () {- typedef struct Ray { Vector3 position; Vector3 direction; } Ray; -} data Ray = Ray { ray'position :: Vector3, ray'direction :: Vector3 } deriving (Eq, Show) p'Ray'position p = plusPtr p 0 p'Ray'position :: Ptr Ray -> Ptr Vector3 p'Ray'direction p = plusPtr p 12 p'Ray'direction :: Ptr Ray -> Ptr Vector3 instance Storable Ray where sizeOf _ = 24 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 12 return $ Ray v0 v1 poke _p (Ray v0 v1) = do pokeByteOff _p 0 v0 pokeByteOff _p 12 v1 return () {- typedef struct RayCollision { _Bool hit; float distance; Vector3 point; Vector3 normal; } RayCollision; -} data RayCollision = RayCollision { rayCollision'hit :: CBool, rayCollision'distance :: CFloat, rayCollision'point :: Vector3, rayCollision'normal :: Vector3 } deriving (Eq, Show) p'RayCollision'hit p = plusPtr p 0 p'RayCollision'hit :: Ptr RayCollision -> Ptr CBool p'RayCollision'distance p = plusPtr p 4 p'RayCollision'distance :: Ptr RayCollision -> Ptr CFloat p'RayCollision'point p = plusPtr p 8 p'RayCollision'point :: Ptr RayCollision -> Ptr Vector3 p'RayCollision'normal p = plusPtr p 20 p'RayCollision'normal :: Ptr RayCollision -> Ptr Vector3 instance Storable RayCollision where sizeOf _ = 32 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 20 return $ RayCollision v0 v1 v2 v3 poke _p (RayCollision v0 v1 v2 v3) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 20 v3 return () {- typedef struct BoundingBox { Vector3 min; Vector3 max; } BoundingBox; -} data BoundingBox = BoundingBox { boundingBox'min :: Vector3, boundingBox'max :: Vector3 } deriving (Eq, Show) p'BoundingBox'min p = plusPtr p 0 p'BoundingBox'min :: Ptr BoundingBox -> Ptr Vector3 p'BoundingBox'max p = plusPtr p 12 p'BoundingBox'max :: Ptr BoundingBox -> Ptr Vector3 instance Storable BoundingBox where sizeOf _ = 24 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 12 return $ BoundingBox v0 v1 poke _p (BoundingBox v0 v1) = do pokeByteOff _p 0 v0 pokeByteOff _p 12 v1 return () {- typedef struct Wave { unsigned int frameCount; unsigned int sampleRate; unsigned int sampleSize; unsigned int channels; void * data; } Wave; -} data Wave = Wave { wave'frameCount :: CUInt, wave'sampleRate :: CUInt, wave'sampleSize :: CUInt, wave'channels :: CUInt, wave'data :: Ptr () } deriving (Eq, Show) p'Wave'frameCount p = plusPtr p 0 p'Wave'frameCount :: Ptr Wave -> Ptr CUInt p'Wave'sampleRate p = plusPtr p 4 p'Wave'sampleRate :: Ptr Wave -> Ptr CUInt p'Wave'sampleSize p = plusPtr p 8 p'Wave'sampleSize :: Ptr Wave -> Ptr CUInt p'Wave'channels p = plusPtr p 12 p'Wave'channels :: Ptr Wave -> Ptr CUInt p'Wave'data p = plusPtr p 16 p'Wave'data :: Ptr Wave -> Ptr (Ptr ()) instance Storable Wave where sizeOf _ = 20 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 return $ Wave v0 v1 v2 v3 v4 poke _p (Wave v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 return () {- typedef struct rAudioBuffer rAudioBuffer; -} data RAudioBuffer = RAudioBuffer {- typedef struct rAudioProcessor rAudioProcessor; -} data RAudioProcessor = RAudioProcessor {- typedef struct AudioStream { rAudioBuffer * buffer; rAudioProcessor * processor; unsigned int sampleRate; unsigned int sampleSize; unsigned int channels; } AudioStream; -} data AudioStream = AudioStream { audioStream'buffer :: Ptr RAudioBuffer, audioStream'processor :: Ptr RAudioProcessor, audioStream'sampleRate :: CUInt, audioStream'sampleSize :: CUInt, audiostream'channels :: CUInt } deriving (Eq, Show) p'AudioStream'buffer p = plusPtr p 0 p'AudioStream'buffer :: Ptr AudioStream -> Ptr (Ptr RAudioBuffer) p'AudioStream'processor p = plusPtr p 4 p'AudioStream'processor :: Ptr AudioStream -> Ptr (Ptr rAudioProcessor) p'AudioStream'sampleRate p = plusPtr p 8 p'AudioStream'sampleRate :: Ptr AudioStream -> Ptr CUInt p'AudioStream'sampleSize p = plusPtr p 12 p'AudioStream'sampleSize :: Ptr AudioStream -> Ptr CUInt p'AudioStream'channels p = plusPtr p 16 p'AudioStream'channels :: Ptr AudioStream -> Ptr CUInt instance Storable AudioStream where sizeOf _ = 20 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 return $ AudioStream v0 v1 v2 v3 v4 poke _p (AudioStream v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 return () {- typedef struct Sound { AudioStream stream; unsigned int frameCount; } Sound; -} data Sound = Sound { sound'stream :: AudioStream, sound'frameCount :: CUInt } deriving (Eq, Show) p'Sound'stream p = plusPtr p 0 p'Sound'stream :: Ptr Sound -> Ptr AudioStream p'Sound'frameCount p = plusPtr p 20 p'Sound'frameCount :: Ptr Sound -> Ptr CUInt instance Storable Sound where sizeOf _ = 24 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 20 return $ Sound v0 v1 poke _p (Sound v0 v1) = do pokeByteOff _p 0 v0 pokeByteOff _p 20 v1 return () {- typedef struct Music { AudioStream stream; unsigned int frameCount; _Bool looping; int ctxType; void * ctxData; } Music; -} data Music = Music { musistream :: AudioStream, musiframeCount :: CUInt, musilooping :: CInt, musictxType :: CInt, musictxData :: Ptr () } deriving (Eq, Show) p'Musistream p = plusPtr p 0 p'Musistream :: Ptr Music -> Ptr AudioStream p'MusiframeCount p = plusPtr p 20 p'MusiframeCount :: Ptr Music -> Ptr CUInt p'Musilooping p = plusPtr p 24 p'Musilooping :: Ptr Music -> Ptr CInt p'MusictxType p = plusPtr p 28 p'MusictxType :: Ptr Music -> Ptr CInt p'MusictxData p = plusPtr p 32 p'MusictxData :: Ptr Music -> Ptr (Ptr ()) instance Storable Music where sizeOf _ = 36 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 20 v2 <- peekByteOff _p 24 v3 <- peekByteOff _p 28 v4 <- peekByteOff _p 32 return $ Music v0 v1 v2 v3 v4 poke _p (Music v0 v1 v2 v3 v4) = do pokeByteOff _p 0 v0 pokeByteOff _p 20 v1 pokeByteOff _p 24 v2 pokeByteOff _p 28 v3 pokeByteOff _p 32 v4 return () {- typedef struct VrDeviceInfo { int hResolution; int vResolution; float hScreenSize; float vScreenSize; float vScreenCenter; float eyeToScreenDistance; float lensSeparationDistance; float interpupillaryDistance; float lensDistortionValues[4]; float chromaAbCorrection[4]; } VrDeviceInfo; -} data VrDeviceInfo = VrDeviceInfo { vrDeviceInfo'hResolution :: CInt, vrDeviceInfo'vResolution :: CInt, vrDeviceInfo'hScreenSize :: CFloat, vrDeviceInfo'vScreenSize :: CFloat, vrDeviceInfo'vScreenCenter :: CFloat, vrDeviceInfo'eyeToScreenDistance :: CFloat, vrDeviceInfo'lensSeparationDistance :: CFloat, vrDeviceInfo'interpupillaryDistance :: CFloat, vrDeviceInfo'lensDistortionValues :: [CFloat], vrDeviceInfo'chromaAbCorrection :: [CFloat] } deriving (Eq, Show) p'VrDeviceInfo'hResolution p = plusPtr p 0 p'VrDeviceInfo'hResolution :: Ptr VrDeviceInfo -> Ptr CInt p'VrDeviceInfo'vResolution p = plusPtr p 4 p'VrDeviceInfo'vResolution :: Ptr VrDeviceInfo -> Ptr CInt p'VrDeviceInfo'hScreenSize p = plusPtr p 8 p'VrDeviceInfo'hScreenSize :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'vScreenSize p = plusPtr p 12 p'VrDeviceInfo'vScreenSize :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'vScreenCenter p = plusPtr p 16 p'VrDeviceInfo'vScreenCenter :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'eyeToScreenDistance p = plusPtr p 20 p'VrDeviceInfo'eyeToScreenDistance :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'lensSeparationDistance p = plusPtr p 24 p'VrDeviceInfo'lensSeparationDistance :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'interpupillaryDistance p = plusPtr p 28 p'VrDeviceInfo'interpupillaryDistance :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'lensDistortionValues p = plusPtr p 32 p'VrDeviceInfo'lensDistortionValues :: Ptr VrDeviceInfo -> Ptr CFloat p'VrDeviceInfo'chromaAbCorrection p = plusPtr p 48 p'VrDeviceInfo'chromaAbCorrection :: Ptr VrDeviceInfo -> Ptr CFloat instance Storable VrDeviceInfo where sizeOf _ = 64 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 v3 <- peekByteOff _p 12 v4 <- peekByteOff _p 16 v5 <- peekByteOff _p 20 v6 <- peekByteOff _p 24 v7 <- peekByteOff _p 28 v8 <- let s8 = div 16 $ sizeOf (undefined :: CFloat) in peekArray s8 (plusPtr _p 32) v9 <- let s9 = div 16 $ sizeOf (undefined :: CFloat) in peekArray s9 (plusPtr _p 48) return $ VrDeviceInfo v0 v1 v2 v3 v4 v5 v6 v7 v8 v9 poke _p (VrDeviceInfo v0 v1 v2 v3 v4 v5 v6 v7 v8 v9) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 pokeByteOff _p 12 v3 pokeByteOff _p 16 v4 pokeByteOff _p 20 v5 pokeByteOff _p 24 v6 pokeByteOff _p 28 v7 let s8 = div 16 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 32) (take s8 v8) let s9 = div 16 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 48) (take s9 v9) return () {- typedef struct VrStereoConfig { Matrix projection[2]; Matrix viewOffset[2]; float leftLensCenter[2]; float rightLensCenter[2]; float leftScreenCenter[2]; float rightScreenCenter[2]; float scale[2]; float scaleIn[2]; } VrStereoConfig; -} data VrStereoConfig = VrStereoConfig { vrStereoConfig'projection :: [Matrix], vrStereoConfig'viewOffset :: [Matrix], vrStereoConfig'leftLensCenter :: [CFloat], vrStereoConfig'rightLensCenter :: [CFloat], vrStereoConfig'leftScreenCenter :: [CFloat], vrStereoConfig'rightScreenCenter :: [CFloat], vrStereoConfig'scale :: [CFloat], vrStereoConfig'scaleIn :: [CFloat] } deriving (Eq, Show) p'VrStereoConfig'projection p = plusPtr p 0 p'VrStereoConfig'projection :: Ptr VrStereoConfig -> Ptr Matrix p'VrStereoConfig'viewOffset p = plusPtr p 128 p'VrStereoConfig'viewOffset :: Ptr VrStereoConfig -> Ptr Matrix p'VrStereoConfig'leftLensCenter p = plusPtr p 256 p'VrStereoConfig'leftLensCenter :: Ptr VrStereoConfig -> Ptr CFloat p'VrStereoConfig'rightLensCenter p = plusPtr p 264 p'VrStereoConfig'rightLensCenter :: Ptr VrStereoConfig -> Ptr CFloat p'VrStereoConfig'leftScreenCenter p = plusPtr p 272 p'VrStereoConfig'leftScreenCenter :: Ptr VrStereoConfig -> Ptr CFloat p'VrStereoConfig'rightScreenCenter p = plusPtr p 280 p'VrStereoConfig'rightScreenCenter :: Ptr VrStereoConfig -> Ptr CFloat p'VrStereoConfig'scale p = plusPtr p 288 p'VrStereoConfig'scale :: Ptr VrStereoConfig -> Ptr CFloat p'VrStereoConfig'scaleIn p = plusPtr p 296 p'VrStereoConfig'scaleIn :: Ptr VrStereoConfig -> Ptr CFloat instance Storable VrStereoConfig where sizeOf _ = 304 alignment _ = 4 peek _p = do v0 <- let s0 = div 128 $ sizeOf (undefined :: Matrix) in peekArray s0 (plusPtr _p 0) v1 <- let s1 = div 128 $ sizeOf (undefined :: Matrix) in peekArray s1 (plusPtr _p 128) v2 <- let s2 = div 8 $ sizeOf (undefined :: CFloat) in peekArray s2 (plusPtr _p 256) v3 <- let s3 = div 8 $ sizeOf (undefined :: CFloat) in peekArray s3 (plusPtr _p 264) v4 <- let s4 = div 8 $ sizeOf (undefined :: CFloat) in peekArray s4 (plusPtr _p 272) v5 <- let s5 = div 8 $ sizeOf (undefined :: CFloat) in peekArray s5 (plusPtr _p 280) v6 <- let s6 = div 8 $ sizeOf (undefined :: CFloat) in peekArray s6 (plusPtr _p 288) v7 <- let s7 = div 8 $ sizeOf (undefined :: CFloat) in peekArray s7 (plusPtr _p 296) return $ VrStereoConfig v0 v1 v2 v3 v4 v5 v6 v7 poke _p (VrStereoConfig v0 v1 v2 v3 v4 v5 v6 v7) = do let s0 = div 128 $ sizeOf (undefined :: Matrix) pokeArray (plusPtr _p 0) (take s0 v0) let s1 = div 128 $ sizeOf (undefined :: Matrix) pokeArray (plusPtr _p 128) (take s1 v1) let s2 = div 8 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 256) (take s2 v2) let s3 = div 8 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 264) (take s3 v3) let s4 = div 8 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 272) (take s4 v4) let s5 = div 8 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 280) (take s5 v5) let s6 = div 8 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 288) (take s6 v6) let s7 = div 8 $ sizeOf (undefined :: CFloat) pokeArray (plusPtr _p 296) (take s7 v7) return () {- typedef struct FilePathList { unsigned int capacity; unsigned int count; char * * paths; } FilePathList; -} data FilePathList = FilePathList { filePathlist'capacity :: CUInt, filePathlist'count :: CUInt, filePathList'paths :: Ptr CString } deriving (Eq, Show) p'FilePathList'capacity p = plusPtr p 0 p'FilePathList'capacity :: Ptr FilePathList -> Ptr CUInt p'FilePathList'count p = plusPtr p 4 p'FilePathList'count :: Ptr FilePathList -> Ptr CUInt p'FilePathList'paths p = plusPtr p 8 p'FilePathList'paths :: Ptr FilePathList -> Ptr (Ptr CString) instance Storable FilePathList where sizeOf _ = 12 alignment _ = 4 peek _p = do v0 <- peekByteOff _p 0 v1 <- peekByteOff _p 4 v2 <- peekByteOff _p 8 return $ FilePathList v0 v1 v2 poke _p (FilePathList v0 v1 v2) = do pokeByteOff _p 0 v0 pokeByteOff _p 4 v1 pokeByteOff _p 8 v2 return ()