api.txt

// Window-related functions
[x] void InitWindow(int width, int height, const char *title)
[x] bool WindowShouldClose(void)
[x] void CloseWindow(void)
[x] bool IsWindowReady(void)
[x] bool IsWindowMinimized(void)
[x] bool IsWindowResized(void)

[x] bool IsWindowState(unsigned int flag)
[x] void SetWindowState(unsigned int flags)
[x] void ClearWindowState(unsigned int flags)
[x] void ToggleFullscreen(void)
[x] void SetWindowIcon(Image image)
[x] void SetWindowTitle(const char *title)
[x] void SetWindowPosition(int x, int y)
[x] void SetWindowMonitor(int monitor)
[x] void SetWindowMinSize(int width, int height)
[x] void SetWindowSize(int width, int height)
[x] void *GetWindowHandle(void)
[x] int GetScreenWidth(void)
[x] int GetScreenHeight(void)
[x] int GetMonitorCount(void)
[x] int GetMonitorWidth(int monitor)
[x] int GetMonitorHeight(int monitor)
[x] int GetMonitorPhysicalWidth(int monitor)
[x] int GetMonitorPhysicalHeight(int monitor)
[x] const char *GetMonitorName(int monitor)
[x] const char *GetClipboardText(void)
[x] void SetClipboardText(const char *text)

// Cursor-related functions
[x] void ShowCursor(void)
[x] void HideCursor(void)
[x] bool IsCursorHidden(void)
[x] void EnableCursor(void)
[x] void DisableCursor(void)
[x] bool IsCursorOnScreen(void)

// Drawing-related functions
[x] void ClearBackground(Color color)
[x] void BeginDrawing(void)
[x] void EndDrawing(void)
[x] void BeginMode2D(Camera2D camera)
[x] void EndMode2D(void)
[x] void BeginMode3D(Camera3D camera)
[x] void EndMode3D(void)
[x] void BeginTextureMode(RenderTexture2D target)
[x] void EndTextureMode(void)

// Screen-space-related functions
[ ] Ray GetMouseRay(Vector2 mousePosition, Camera camera)
[ ] Vector2 GetWorldToScreen(Vector3 position, Camera camera)
[ ] Matrix GetCameraMatrix(Camera camera)

// Timing-related functions
[x] void SetTargetFPS(int fps)
[x] int GetFPS(void)
[x] float GetFrameTime(void)
[x] double GetTime(void)

// Color-related functions
[ ] int ColorToInt(Color color)
[ ] Vector4 ColorNormalize(Color color)
[ ] Vector3 ColorToHSV(Color color)
[ ] Color ColorFromHSV(Vector3 hsv)
[ ] Color GetColor(int hexValue)
[ ] Color Fade(Color color, float alpha)

// Misc. functions
[x] void SetConfigFlags(unsigned int flags)
[x] void SetTraceLogLevel(int logType)
[x] void SetTraceLogCallback(TraceLogCallback callback)
[x] void TraceLog(int logType, const char *text, ...)
[x] void TakeScreenshot(const char *fileName)

// Files management functions
[x] char **GetDroppedFiles(int *count)
[x] void ClearDroppedFiles(void)

// Persistent storage management
[x] void SaveStorageValue(int position, int value)
[x] int LoadStorageValue(int position)

[x] void OpenURL(const char *url)

//------------------------------------------------------------------------------------
// Input Handling Functions
//------------------------------------------------------------------------------------

// Input-related functions: keyboard
[x] bool IsKeyPressed(int key)
[x] bool IsKeyDown(int key)
[x] bool IsKeyReleased(int key)
[x] bool IsKeyUp(int key)
[x] int GetKeyPressed(void)
[x] void SetExitKey(int key)

// Input-related functions: gamepads
[x] bool IsGamepadAvailable(int gamepad)
[x] bool IsGamepadName(int gamepad, const char *name)
[x] const char *GetGamepadName(int gamepad)
[x] bool IsGamepadButtonPressed(int gamepad, int button)
[x] bool IsGamepadButtonDown(int gamepad, int button)
[x] bool IsGamepadButtonReleased(int gamepad, int button)
[x] bool IsGamepadButtonUp(int gamepad, int button)
[x] int GetGamepadButtonPressed(void)
[x] int GetGamepadAxisCount(int gamepad)
[x] float GetGamepadAxisMovement(int gamepad, int axis)

// Input-related functions: mouse
[x] bool IsMouseButtonPressed(int button)
[x] bool IsMouseButtonDown(int button)
[x] bool IsMouseButtonReleased(int button)
[x] bool IsMouseButtonUp(int button)
[x] int GetMouseX(void)
[x] int GetMouseY(void)
[x] Vector2 GetMousePosition(void)
[x] void SetMousePosition(int x, int y)
[x] void SetMouseOffset(int offsetX, int offsetY)
[x] void SetMouseScale(float scaleX, float scaleY)
[x] float GetMouseWheelMove(void)

// Input-related functions: touch
[x] int GetTouchX(void)
[x] int GetTouchY(void)
[x] Vector2 GetTouchPosition(int index)

//------------------------------------------------------------------------------------
// Gestures and Touch Handling Functions (Module: gestures)
//------------------------------------------------------------------------------------
[x] void SetGesturesEnabled(unsigned int gestureFlags)
[x] bool IsGestureDetected(int gesture)
[x] int GetGestureDetected(void)
[x] int GetTouchPointsCount(void)
[x] float GetGestureHoldDuration(void)
[x] Vector2 GetGestureDragVector(void)
[x] float GetGestureDragAngle(void)
[x] Vector2 GetGesturePinchVector(void)
[x] float GetGesturePinchAngle(void)

//------------------------------------------------------------------------------------
// Camera System Functions (Module: camera)
//------------------------------------------------------------------------------------
[x] void SetCameraMode(Camera camera, int mode)
[x] void UpdateCamera(Camera *camera)
[x] void SetCameraPanControl(int panKey)
[x] void SetCameraAltControl(int altKey)
[x] void SetCameraSmoothZoomControl(int szKey)
[x] void SetCameraMoveControls(int frontKey, int backKey,
                            int rightKey, int leftKey,
                            int upKey, int downKey)

// Basic shapes drawing functions
[x] void DrawPixel(int posX, int posY, Color color)
[x] void DrawPixelV(Vector2 position, Color color)
[x] void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color)
[x] void DrawLineV(Vector2 startPos, Vector2 endPos, Color color)
[x] void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color)
[x] void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color)
[x] void DrawLineStrip(Vector2 *points, int numPoints, Color color)
[x] void DrawCircle(int centerX, int centerY, float radius, Color color)
[x] void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color)
[x] void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color)
[x] void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2)
[x] void DrawCircleV(Vector2 center, float radius, Color color)
[x] void DrawCircleLines(int centerX, int centerY, float radius, Color color)
[x] void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color)
[x] void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color)
[x] void DrawRectangle(int posX, int posY, int width, int height, Color color)
[x] void DrawRectangleV(Vector2 position, Vector2 size, Color color)
[x] void DrawRectangleRec(Rectangle rec, Color color)
[x] void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color)
[x] void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2)
[x] void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2)
[x] void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4)
[x] void DrawRectangleLines(int posX, int posY, int width, int height, Color color)
[x] void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color)
[x] void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color)
[x] void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color)
[x] void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
[x] void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
[x] void DrawTriangleFan(Vector2 *points, int numPoints, Color color)
[x] void DrawTriangleStrip(Vector2 *points, int numPoints, Color color)
[x] void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color)

[ ] void SetShapesTexture(Texture2D texture, Rectangle source)

// Basic shapes collision detection functions
[ ] bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2)
[ ] bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2)
[ ] bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec)
[ ] Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2)
[ ] bool CheckCollisionPointRec(Vector2 point, Rectangle rec)
[ ] bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius)
[ ] bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3)

// Image/Texture2D data loading/unloading/saving functions
[x] Image LoadImage(const char *fileName)
[x] Image LoadImagePro(void *data, int width, int height, int format)
[ ] Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize)
[x] void ExportImage(Image image, const char *fileName)
[x] void ExportImageAsCode(Image image, const char *fileName)
[x] Texture2D LoadTexture(const char *fileName)
[x] Texture2D LoadTextureFromImage(Image image)
[x] TextureCubemap LoadTextureCubemap(Image image, int layoutType)
[x] RenderTexture2D LoadRenderTexture(int width, int height)
[x] void UnloadImage(Image image)
[x] void UnloadTexture(Texture2D texture)
[x] void UnloadRenderTexture(RenderTexture2D target)
[ ] Color *GetImageData(Image image)
[ ] Vector4 *GetImageDataNormalized(Image image)
[ ] int GetPixelDataSize(int width, int height, int format)
[x] Image GetTextureData(Texture2D texture)
[x] Image GetScreenData(void)
[ ] void UpdateTexture(Texture2D texture, const void *pixels)

// Image manipulation functions
[x] Image ImageCopy(Image image)
[x] void ImageToPOT(Image *image, Color fillColor)
[x] void ImageFormat(Image *image, int newFormat)
[x] void ImageAlphaMask(Image *image, Image alphaMask)
[x] void ImageAlphaClear(Image *image, Color color, float threshold)
[x] void ImageAlphaCrop(Image *image, float threshold)
[x] void ImageAlphaPremultiply(Image *image)
[x] void ImageCrop(Image *image, Rectangle crop)
[x] void ImageResize(Image *image, int newWidth, int newHeight)
[x] void ImageResizeNN(Image *image, int newWidth,int newHeight)
[x] void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color color)
[x] void ImageMipmaps(Image *image)
[x] void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
[x] Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount)
[x] Image ImageText(const char *text, int fontSize, Color color)
[x] Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint)
[x] void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec)
[x] void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color)
[x] void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color)
[x] void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color)
[x] void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text, float fontSize, float spacing, Color color)
[x] void ImageFlipVertical(Image *image)
[x] void ImageFlipHorizontal(Image *image)
[x] void ImageRotateCW(Image *image)
[x] void ImageRotateCCW(Image *image)
[x] void ImageColorTint(Image *image, Color color)
[x] void ImageColorInvert(Image *image)
[x] void ImageColorGrayscale(Image *image)
[x] void ImageColorContrast(Image *image, float contrast)
[x] void ImageColorBrightness(Image *image, int brightness)
[x] void ImageColorReplace(Image *image, Color color, Color replace)

// Image generation functions
[x] Image GenImageColor(int width, int height, Color color)
[x] Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end)
[x] Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer)
[x] Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer)
[x] Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2)
[x] Image GenImageWhiteNoise(int width, int height, float factor)
[x] Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale)
[x] Image GenImageCellular(int width, int height, int tileSize)

// Texture2D configuration functions
[x] void GenTextureMipmaps(Texture2D *texture)
[x] void SetTextureFilter(Texture2D texture, int filterMode)
[x] void SetTextureWrap(Texture2D texture, int wrapMode)

// Texture2D drawing functions
[x] void DrawTexture(Texture2D texture, int posX, int posY, Color tint)
[x] void DrawTextureV(Texture2D texture, Vector2 position, Color tint)
[x] void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)
[x] void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint)
[x] void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint)
[x] void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint)
[ ] void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint)

// Font loading/unloading functions
[x] Font GetFontDefault(void)
[x] Font LoadFont(const char *fileName)
[x] Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount)
[ ] Font LoadFontFromImage(Image image, Color key, int firstChar)
[ ] CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type)
[ ] Image GenImageFontAtlas(CharInfo *chars, int charsCount, int fontSize, int padding, int packMethod)
[x] void UnloadFont(Font font)

// Text drawing functions
[x] void DrawFPS(int posX, int posY)
[x] void DrawText(const char *text, int posX, int posY, int fontSize, Color color)
[x] void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint)
[x] void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint)
[x] void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint,
                      int selectStart, int selectLength, Color selectText, Color selectBack)

// Text misc. functions
[x] int MeasureText(const char *text, int fontSize)
[x] Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing)
[x] int GetGlyphIndex(Font font, int character)

// Basic geometric 3D shapes drawing functions
[x] void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color)
[x] void DrawPoint3D(Vector3 position, Color color)
[x] void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color)
[x] void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color)
[x] void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color)
[x] void DrawCube(Vector3 position, float width, float height, float length, Color color)
[x] void DrawCubeV(Vector3 position, Vector3 size, Color color)
[x] void DrawCubeWires(Vector3 position, float width, float height, float length, Color color)
[x] void DrawCubeWiresV(Vector3 position, Vector3 size, Color color)
[x] void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color)
[x] void DrawSphere(Vector3 centerPos, float radius, Color color)
[x] void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color)
[x] void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color)
[x] void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color)
[x] void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)
[x] void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color)
[x] void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color)
[x] void DrawPlane(Vector3 centerPos, Vector2 size, Color color)
[x] void DrawRay(Ray ray, Color color)
[x] void DrawGrid(int slices, float spacing)

// Model loading/unloading functions
[x] Model LoadModel(const char *fileName)
[x] Model LoadModelFromMesh(Mesh mesh)
[x] void UnloadModel(Model model)
[x] BoundingBox GetModelBoundingBox(Model model)

// Mesh loading/unloading functions
[x] void ExportMesh(Mesh mesh, const char *fileName)
[x] void UploadMesh(Mesh *mesh, bool dynamic)
[x] void UnloadMesh(Mesh *mesh)
[x] void DrawMesh(Mesh mesh, Material material, Matrix transform)
[x] void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances)

// Material loading/unloading functions
[x] Material *LoadMaterials(const char *fileName, int *materialCount)
[x] Material LoadMaterialDefault(void)
[x] void UnloadMaterial(Material material)
[x] void SetMaterialTexture(Material *material, int mapType, Texture2D texture)
[x] void SetModelMeshMaterial(Model *model, int meshId, int materialId)

// Model animations loading/unloading functions
[x] ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount)
[x] void UpdateModelAnimation(Model model, ModelAnimation anim, int frame)
[x] void UnloadModelAnimation(ModelAnimation anim)
[x] void UnloadModelAnimations(ModelAnimation *animations, unsigned int count)
[x] bool IsModelAnimationValid(Model model, ModelAnimation anim)

// Mesh generation functions
[x] Mesh GenMeshPoly(int sides, float radius)
[x] Mesh GenMeshPlane(float width, float length, int resX, int resZ)
[x] Mesh GenMeshCube(float width, float height, float length)
[x] Mesh GenMeshSphere(float radius, int rings, int slices)
[x] Mesh GenMeshHemiSphere(float radius, int rings, int slices)
[x] Mesh GenMeshCylinder(float radius, float height, int slices)
[x] Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
[x] Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)
[x] Mesh GenMeshHeightmap(Image heightmap, Vector3 size)
[x] Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)

// Mesh manipulation functions
[x] BoundingBox GetMeshBoundingBox(Mesh mesh)
[x] void GenMeshTangents(Mesh *mesh)
[x] void GenMeshBinormals(Mesh *mesh)

// Model drawing functions
[x] void DrawModel(Model model, Vector3 position, float scale, Color tint)
[x] void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)
[x] void DrawModelWires(Model model, Vector3 position, float scale, Color tint)
[x] void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)
[x] void DrawBoundingBox(BoundingBox box, Color color)
[x] void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint)
[x] void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint)
[x] void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint)

// Collision detection functions
[x] bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB)
[x] bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2)
[x] bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radiusSphere)
[x] RayCollision GetRayCollisionSphere(Ray ray, Vector3 spherePosition, float sphereRadius)
[x] RayCollision GetRayCollisionBox(Ray ray, BoundingBox box)
[x] RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform)
[x] RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3)
[x] RayCollision GetRayCollisionModel(Ray ray, Model *model)
[x] RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4)

// Shader loading/unloading functions
[ ] char *LoadText(const char *fileName)
[x] Shader LoadShader(const char *vsFileName, const char *fsFileName)
[ ] Shader LoadShaderCode(char *vsCode, char *fsCode)
[x] void UnloadShader(Shader shader)

[ ] Shader GetShaderDefault(void)
[ ] Texture2D GetTextureDefault(void)

// Shader configuration functions
[x] int GetShaderLocation(Shader shader, const char *uniformName)
[x] void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType)
[ ] void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count)
[ ] void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
[ ] void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture)
[ ] void SetMatrixProjection(Matrix proj)
[ ] void SetMatrixModelview(Matrix view)
[ ] Matrix GetMatrixModelview()

// Shading begin/end functions
[x] void BeginShaderMode(Shader shader)
[x] void EndShaderMode(void)
[ ] void BeginBlendMode(int mode)
[ ] void EndBlendMode(void)
[ ] void BeginScissorMode(int x, int y, int width, int height)
[ ] void EndScissorMode(void)

// VR control functions
[ ] void InitVrSimulator(void)
[ ] void CloseVrSimulator(void)
[ ] void UpdateVrTracking(Camera *camera)
[ ] void SetVrConfiguration(VrDeviceInfo info, Shader distortion)
[ ] bool IsVrSimulatorReady(void)
[ ] void ToggleVrMode(void)
[ ] void BeginVrDrawing(void)
[ ] void EndVrDrawing(void)

// Audio device management functions
[x] void InitAudioDevice(void)
[x] void CloseAudioDevice(void)
[x] bool IsAudioDeviceReady(void)
[x] void SetMasterVolume(float volume)

// Wave/Sound loading/unloading functions
[x] Wave LoadWave(const char *fileName)
[ ] Wave LoadWaveEx(void *data, int sampleCount, int sampleRate, int sampleSize, int channels)
[x] Sound LoadSound(const char *fileName)
[x] Sound LoadSoundFromWave(Wave wave)
[ ] void UpdateSound(Sound sound, const void *data, int samplesCount)
[x] void UnloadWave(Wave wave)
[x] void UnloadSound(Sound sound)
[x] void ExportWave(Wave wave, const char *fileName)
[x] void ExportWaveAsCode(Wave wave, const char *fileName)

// Wave/Sound management functions
[x] void PlaySound(Sound sound)
[x] void PauseSound(Sound sound)
[x] void ResumeSound(Sound sound)
[x] void StopSound(Sound sound)
[x] bool IsSoundPlaying(Sound sound)
[x] void SetSoundVolume(Sound sound, float volume)
[x] void SetSoundPitch(Sound sound, float pitch)
[ ] void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
[x] Wave WaveCopy(Wave wave)
[ ] void WaveCrop(Wave *wave, int initSample, int finalSample)
[ ] float *GetWaveData(Wave wave)

// Music management functions
[x] Music LoadMusicStream(const char *fileName)
[x] void UnloadMusicStream(Music music)
[x] void PlayMusicStream(Music music)
[x] void UpdateMusicStream(Music music)
[x] void StopMusicStream(Music music)
[x] void PauseMusicStream(Music music)
[x] void ResumeMusicStream(Music music)
[x] bool IsMusicPlaying(Music music)
[x] void SetMusicVolume(Music music, float volume)
[x] void SetMusicPitch(Music music, float pitch)
[x] float GetMusicTimeLength(Music music)
[x] float GetMusicTimePlayed(Music music)

// AudioStream management functions
[x] AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels)
[x] void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount)
[x] void CloseAudioStream(AudioStream stream)
[x] bool IsAudioStreamProcessed(AudioStream stream)
[x] void PlayAudioStream(AudioStream stream)
[x] void PauseAudioStream(AudioStream stream)
[x] void ResumeAudioStream(AudioStream stream)
[x] bool IsAudioStreamPlaying(AudioStream stream)
[x] void StopAudioStream(AudioStream stream)
[x] void SetAudioStreamVolume(AudioStream stream, float volume)
[x] void SetAudioStreamPitch(AudioStream stream, float pitch)