|
|
|
@ -20,7 +20,8 @@ RLAPI void ToggleFullscreen(void); // Toggle wind |
|
|
|
RLAPI void MaximizeWindow(void); // Set window state: maximized, if resizable (only PLATFORM_DESKTOP) |
|
|
|
RLAPI void MinimizeWindow(void); // Set window state: minimized, if resizable (only PLATFORM_DESKTOP) |
|
|
|
RLAPI void RestoreWindow(void); // Set window state: not minimized/maximized (only PLATFORM_DESKTOP) |
|
|
|
RLAPI void SetWindowIcon(Image image); // Set icon for window (only PLATFORM_DESKTOP) |
|
|
|
RLAPI void SetWindowIcon(Image image); // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP) |
|
|
|
RLAPI void SetWindowIcons(Image *images, int count); // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP) |
|
|
|
RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP) |
|
|
|
RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP) |
|
|
|
RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode) |
|
|
|
@ -50,7 +51,7 @@ RLAPI void DisableEventWaiting(void); // Disable wai |
|
|
|
|
|
|
|
// Custom frame control functions |
|
|
|
// NOTE: Those functions are intended for advance users that want full control over the frame processing |
|
|
|
// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timming + PollInputEvents() |
|
|
|
// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents() |
|
|
|
// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL |
|
|
|
RLAPI void SwapScreenBuffer(void); // Swap back buffer with front buffer (screen drawing) |
|
|
|
RLAPI void PollInputEvents(void); // Register all input events |
|
|
|
@ -91,6 +92,7 @@ RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR s |
|
|
|
// NOTE: Shader functionality is not available on OpenGL 1.1 |
|
|
|
RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations |
|
|
|
RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations |
|
|
|
RLAPI bool IsShaderReady(Shader shader); // Check if a shader is ready |
|
|
|
RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location |
|
|
|
RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName); // Get shader attribute location |
|
|
|
RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType); // Set shader uniform value |
|
|
|
@ -122,8 +124,8 @@ RLAPI void SetConfigFlags(unsigned int flags); // Setup init |
|
|
|
|
|
|
|
RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) |
|
|
|
RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level |
|
|
|
RLAPI void *MemAlloc(int size); // Internal memory allocator |
|
|
|
RLAPI void *MemRealloc(void *ptr, int size); // Internal memory reallocator |
|
|
|
RLAPI void *MemAlloc(unsigned int size); // Internal memory allocator |
|
|
|
RLAPI void *MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator |
|
|
|
RLAPI void MemFree(void *ptr); // Internal memory free |
|
|
|
|
|
|
|
RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available) |
|
|
|
@ -140,7 +142,7 @@ RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom |
|
|
|
RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read) |
|
|
|
RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() |
|
|
|
RLAPI bool SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write), returns true on success |
|
|
|
RLAPI bool ExportDataAsCode(const char *data, unsigned int size, const char *fileName); // Export data to code (.h), returns true on success |
|
|
|
RLAPI bool ExportDataAsCode(const unsigned char *data, unsigned int size, const char *fileName); // Export data to code (.h), returns true on success |
|
|
|
RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string |
|
|
|
RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText() |
|
|
|
RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success |
|
|
|
@ -234,13 +236,8 @@ RLAPI float GetGesturePinchAngle(void); // Get gesture pinch ang |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Camera System Functions (Module: rcamera) |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
RLAPI void SetCameraMode(Camera camera, int mode); // Set camera mode (multiple camera modes available) |
|
|
|
RLAPI void UpdateCamera(Camera *camera); // Update camera position for selected mode |
|
|
|
|
|
|
|
RLAPI void SetCameraPanControl(int keyPan); // Set camera pan key to combine with mouse movement (free camera) |
|
|
|
RLAPI void SetCameraAltControl(int keyAlt); // Set camera alt key to combine with mouse movement (free camera) |
|
|
|
RLAPI void SetCameraSmoothZoomControl(int keySmoothZoom); // Set camera smooth zoom key to combine with mouse (free camera) |
|
|
|
RLAPI void SetCameraMoveControls(int keyFront, int keyBack, int keyRight, int keyLeft, int keyUp, int keyDown); // Set camera move controls (1st person and 3rd person cameras) |
|
|
|
RLAPI void UpdateCamera(Camera *camera, int mode); // Update camera position for selected mode |
|
|
|
RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Basic Shapes Drawing Functions (Module: shapes) |
|
|
|
@ -296,6 +293,7 @@ RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); |
|
|
|
RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle |
|
|
|
RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle |
|
|
|
RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle |
|
|
|
RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices |
|
|
|
RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference |
|
|
|
RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] |
|
|
|
RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision |
|
|
|
@ -305,13 +303,14 @@ RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
|
|
|
|
// Image loading functions |
|
|
|
// NOTE: This functions do not require GPU access |
|
|
|
// NOTE: These functions do not require GPU access |
|
|
|
RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) |
|
|
|
RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data |
|
|
|
RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) |
|
|
|
RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' |
|
|
|
RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data |
|
|
|
RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) |
|
|
|
RLAPI bool IsImageReady(Image image); // Check if an image is ready |
|
|
|
RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) |
|
|
|
RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success |
|
|
|
RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success |
|
|
|
@ -323,7 +322,9 @@ RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); |
|
|
|
RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient |
|
|
|
RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked |
|
|
|
RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise |
|
|
|
RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise |
|
|
|
RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells |
|
|
|
RLAPI Image GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data |
|
|
|
|
|
|
|
// Image manipulation functions |
|
|
|
RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) |
|
|
|
@ -337,6 +338,7 @@ RLAPI void ImageAlphaCrop(Image *image, float threshold); |
|
|
|
RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color |
|
|
|
RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image |
|
|
|
RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel |
|
|
|
RLAPI void ImageBlurGaussian(Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation |
|
|
|
RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) |
|
|
|
RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) |
|
|
|
RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color |
|
|
|
@ -366,8 +368,10 @@ RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); |
|
|
|
RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) |
|
|
|
RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image |
|
|
|
RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) |
|
|
|
RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle within an image |
|
|
|
RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw circle within an image (Vector version) |
|
|
|
RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw a filled circle within an image |
|
|
|
RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw a filled circle within an image (Vector version) |
|
|
|
RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle outline within an image |
|
|
|
RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color); // Draw circle outline within an image (Vector version) |
|
|
|
RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image |
|
|
|
RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) |
|
|
|
RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image |
|
|
|
@ -382,7 +386,9 @@ RLAPI Texture2D LoadTexture(const char *fileName); |
|
|
|
RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data |
|
|
|
RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported |
|
|
|
RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) |
|
|
|
RLAPI bool IsTextureReady(Texture2D texture); // Check if a texture is ready |
|
|
|
RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) |
|
|
|
RLAPI bool IsRenderTextureReady(RenderTexture2D target); // Check if a render texture is ready |
|
|
|
RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) |
|
|
|
RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data |
|
|
|
RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data |
|
|
|
@ -397,11 +403,8 @@ RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); |
|
|
|
RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 |
|
|
|
RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters |
|
|
|
RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle |
|
|
|
RLAPI void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint); // Draw texture quad with tiling and offset parameters |
|
|
|
RLAPI void DrawTextureTiled(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, float scale, Color tint); // Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest. |
|
|
|
RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters |
|
|
|
RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely |
|
|
|
RLAPI void DrawTexturePoly(Texture2D texture, Vector2 center, Vector2 *points, Vector2 *texcoords, int pointCount, Color tint); // Draw a textured polygon |
|
|
|
RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters |
|
|
|
RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely |
|
|
|
|
|
|
|
// Color/pixel related functions |
|
|
|
RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f |
|
|
|
@ -410,6 +413,9 @@ RLAPI Vector4 ColorNormalize(Color color); // G |
|
|
|
RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1] |
|
|
|
RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] |
|
|
|
RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] |
|
|
|
RLAPI Color ColorTint(Color color, Color tint); // Get color multiplied with another color |
|
|
|
RLAPI Color ColorBrightness(Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f |
|
|
|
RLAPI Color ColorContrast(Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f |
|
|
|
RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f |
|
|
|
RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint |
|
|
|
RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value |
|
|
|
@ -427,6 +433,7 @@ RLAPI Font LoadFont(const char *fileName); |
|
|
|
RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int glyphCount); // Load font from file with extended parameters, use NULL for fontChars and 0 for glyphCount to load the default character set |
|
|
|
RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) |
|
|
|
RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' |
|
|
|
RLAPI bool IsFontReady(Font font); // Check if a font is ready |
|
|
|
RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int glyphCount, int type); // Load font data for further use |
|
|
|
RLAPI Image GenImageFontAtlas(const GlyphInfo *chars, Rectangle **recs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info |
|
|
|
RLAPI void UnloadFontData(GlyphInfo *chars, int glyphCount); // Unload font chars info data (RAM) |
|
|
|
@ -449,12 +456,15 @@ RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); |
|
|
|
RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found |
|
|
|
|
|
|
|
// Text codepoints management functions (unicode characters) |
|
|
|
RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter |
|
|
|
RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory |
|
|
|
RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string |
|
|
|
RLAPI int GetCodepoint(const char *text, int *bytesProcessed); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure |
|
|
|
RLAPI const char *CodepointToUTF8(int codepoint, int *byteSize); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) |
|
|
|
RLAPI char *TextCodepointsToUTF8(const int *codepoints, int length); // Encode text as codepoints array into UTF-8 text string (WARNING: memory must be freed!) |
|
|
|
RLAPI char *LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array |
|
|
|
RLAPI void UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array |
|
|
|
RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter |
|
|
|
RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory |
|
|
|
RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string |
|
|
|
RLAPI int GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure |
|
|
|
RLAPI int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure |
|
|
|
RLAPI int GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure |
|
|
|
RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) |
|
|
|
|
|
|
|
// Text strings management functions (no UTF-8 strings, only byte chars) |
|
|
|
// NOTE: Some strings allocate memory internally for returned strings, just be careful! |
|
|
|
@ -488,8 +498,6 @@ RLAPI void DrawCube(Vector3 position, float width, float height, float length, C |
|
|
|
RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) |
|
|
|
RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires |
|
|
|
RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) |
|
|
|
RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured |
|
|
|
RLAPI void DrawCubeTextureRec(Texture2D texture, Rectangle source, Vector3 position, float width, float height, float length, Color color); // Draw cube with a region of a texture |
|
|
|
RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere |
|
|
|
RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters |
|
|
|
RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires |
|
|
|
@ -497,6 +505,8 @@ RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, f |
|
|
|
RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos |
|
|
|
RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires |
|
|
|
RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos |
|
|
|
RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos |
|
|
|
RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos |
|
|
|
RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ |
|
|
|
RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line |
|
|
|
RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) |
|
|
|
@ -508,16 +518,16 @@ RLAPI void DrawGrid(int slices, float spacing); |
|
|
|
// Model management functions |
|
|
|
RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) |
|
|
|
RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) |
|
|
|
RLAPI bool IsModelReady(Model model); // Check if a model is ready |
|
|
|
RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) |
|
|
|
RLAPI void UnloadModelKeepMeshes(Model model); // Unload model (but not meshes) from memory (RAM and/or VRAM) |
|
|
|
RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) |
|
|
|
|
|
|
|
// Model drawing functions |
|
|
|
RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) |
|
|
|
RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) |
|
|
|
RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters |
|
|
|
RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) |
|
|
|
RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) |
|
|
|
RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters |
|
|
|
RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) |
|
|
|
RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) |
|
|
|
RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint); // Draw a billboard texture |
|
|
|
RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source |
|
|
|
RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation |
|
|
|
@ -548,6 +558,7 @@ RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); |
|
|
|
// Material loading/unloading functions |
|
|
|
RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file |
|
|
|
RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) |
|
|
|
RLAPI bool IsMaterialReady(Material material); // Check if a material is ready |
|
|
|
RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) |
|
|
|
RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) |
|
|
|
RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh |
|
|
|
@ -583,8 +594,10 @@ RLAPI void SetMasterVolume(float volume); // Set mas |
|
|
|
// Wave/Sound loading/unloading functions |
|
|
|
RLAPI Wave LoadWave(const char *fileName); // Load wave data from file |
|
|
|
RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' |
|
|
|
RLAPI bool IsWaveReady(Wave wave); // Checks if wave data is ready |
|
|
|
RLAPI Sound LoadSound(const char *fileName); // Load sound from file |
|
|
|
RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data |
|
|
|
RLAPI bool IsSoundReady(Sound sound); // Checks if a sound is ready |
|
|
|
RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data |
|
|
|
RLAPI void UnloadWave(Wave wave); // Unload wave data |
|
|
|
RLAPI void UnloadSound(Sound sound); // Unload sound |
|
|
|
@ -596,9 +609,6 @@ RLAPI void PlaySound(Sound sound); // Play a |
|
|
|
RLAPI void StopSound(Sound sound); // Stop playing a sound |
|
|
|
RLAPI void PauseSound(Sound sound); // Pause a sound |
|
|
|
RLAPI void ResumeSound(Sound sound); // Resume a paused sound |
|
|
|
RLAPI void PlaySoundMulti(Sound sound); // Play a sound (using multichannel buffer pool) |
|
|
|
RLAPI void StopSoundMulti(void); // Stop any sound playing (using multichannel buffer pool) |
|
|
|
RLAPI int GetSoundsPlaying(void); // Get number of sounds playing in the multichannel |
|
|
|
RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing |
|
|
|
RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) |
|
|
|
RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) |
|
|
|
@ -612,6 +622,7 @@ RLAPI void UnloadWaveSamples(float *samples); // Unload |
|
|
|
// Music management functions |
|
|
|
RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file |
|
|
|
RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data |
|
|
|
RLAPI bool IsMusicReady(Music music); // Checks if a music stream is ready |
|
|
|
RLAPI void UnloadMusicStream(Music music); // Unload music stream |
|
|
|
RLAPI void PlayMusicStream(Music music); // Start music playing |
|
|
|
RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing |
|
|
|
@ -628,6 +639,7 @@ RLAPI float GetMusicTimePlayed(Music music); // Get cur |
|
|
|
|
|
|
|
// AudioStream management functions |
|
|
|
RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) |
|
|
|
RLAPI bool IsAudioStreamReady(AudioStream stream); // Checks if an audio stream is ready |
|
|
|
RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory |
|
|
|
RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data |
|
|
|
RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill |
|
|
|
@ -645,3 +657,6 @@ RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); |
|
|
|
RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream |
|
|
|
RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream |
|
|
|
|
|
|
|
RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline |
|
|
|
RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline |
|
|
|
|
Ray
2 years ago