|
|
|
@ -30,9 +30,10 @@ RLAPI void *GetWindowHandle(void); // Get native |
|
|
|
RLAPI int GetScreenWidth(void); // Get current screen width |
|
|
|
RLAPI int GetScreenHeight(void); // Get current screen height |
|
|
|
RLAPI int GetMonitorCount(void); // Get number of connected monitors |
|
|
|
RLAPI int GetCurrentMonitor(void); // Get current connected monitor |
|
|
|
RLAPI Vector2 GetMonitorPosition(int monitor); // Get specified monitor position |
|
|
|
RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width |
|
|
|
RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height |
|
|
|
RLAPI int GetMonitorWidth(int monitor); // Get specified monitor width (max available by monitor) |
|
|
|
RLAPI int GetMonitorHeight(int monitor); // Get specified monitor height (max available by monitor) |
|
|
|
RLAPI int GetMonitorPhysicalWidth(int monitor); // Get specified monitor physical width in millimetres |
|
|
|
RLAPI int GetMonitorPhysicalHeight(int monitor); // Get specified monitor physical height in millimetres |
|
|
|
RLAPI int GetMonitorRefreshRate(int monitor); // Get specified monitor refresh rate |
|
|
|
@ -60,8 +61,30 @@ RLAPI void BeginMode3D(Camera3D camera); // Initializes |
|
|
|
RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode |
|
|
|
RLAPI void BeginTextureMode(RenderTexture2D target); // Initializes render texture for drawing |
|
|
|
RLAPI void EndTextureMode(void); // Ends drawing to render texture |
|
|
|
RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing |
|
|
|
RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) |
|
|
|
RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied) |
|
|
|
RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) |
|
|
|
RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing) |
|
|
|
RLAPI void EndScissorMode(void); // End scissor mode |
|
|
|
RLAPI void BeginVrStereoMode(VrStereoConfig config); // Begin stereo rendering (requires VR simulator) |
|
|
|
RLAPI void EndVrStereoMode(void); // End stereo rendering (requires VR simulator) |
|
|
|
|
|
|
|
// VR stereo config functions for VR simulator |
|
|
|
RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device); // Load VR stereo config for VR simulator device parameters |
|
|
|
RLAPI void UnloadVrStereoConfig(VrStereoConfig config); // Unload VR stereo config |
|
|
|
|
|
|
|
// Shader management functions |
|
|
|
// 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 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 |
|
|
|
RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count); // Set shader uniform value vector |
|
|
|
RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat); // Set shader uniform value (matrix 4x4) |
|
|
|
RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d) |
|
|
|
RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) |
|
|
|
|
|
|
|
// Screen-space-related functions |
|
|
|
RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Returns a ray trace from mouse position |
|
|
|
@ -75,21 +98,27 @@ RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Returns |
|
|
|
// Timing-related functions |
|
|
|
RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum) |
|
|
|
RLAPI int GetFPS(void); // Returns current FPS |
|
|
|
RLAPI float GetFrameTime(void); // Returns time in seconds for last frame drawn |
|
|
|
RLAPI float GetFrameTime(void); // Returns time in seconds for last frame drawn (delta time) |
|
|
|
RLAPI double GetTime(void); // Returns elapsed time in seconds since InitWindow() |
|
|
|
|
|
|
|
// Misc. functions |
|
|
|
RLAPI int GetRandomValue(int min, int max); // Returns a random value between min and max (both included) |
|
|
|
RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (filename extension defines format) |
|
|
|
RLAPI void SetConfigFlags(unsigned int flags); // Setup init configuration flags (view FLAGS) |
|
|
|
|
|
|
|
RLAPI void SetTraceLogLevel(int logType); // Set the current threshold (minimum) log level |
|
|
|
RLAPI void SetTraceLogExit(int logType); // Set the exit threshold (minimum) log level |
|
|
|
RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set a trace log callback to enable custom logging |
|
|
|
RLAPI void TraceLog(int logType, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR) |
|
|
|
|
|
|
|
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 MemFree(void *ptr); // Internal memory free |
|
|
|
RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (saved a .png) |
|
|
|
RLAPI int GetRandomValue(int min, int max); // Returns a random value between min and max (both included) |
|
|
|
|
|
|
|
// Set custom callbacks |
|
|
|
// WARNING: Callbacks setup is intended for advance users |
|
|
|
RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log |
|
|
|
RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader |
|
|
|
RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver |
|
|
|
RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader |
|
|
|
RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver |
|
|
|
|
|
|
|
// Files management functions |
|
|
|
RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read) |
|
|
|
@ -100,8 +129,8 @@ RLAPI void UnloadFileText(unsigned char *text); // Unload file |
|
|
|
RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success |
|
|
|
RLAPI bool FileExists(const char *fileName); // Check if file exists |
|
|
|
RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists |
|
|
|
RLAPI bool IsFileExtension(const char *fileName, const char *ext);// Check file extension (including point: .png, .wav) |
|
|
|
RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (including point: ".png") |
|
|
|
RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) |
|
|
|
RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: ".png") |
|
|
|
RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string |
|
|
|
RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) |
|
|
|
RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) |
|
|
|
@ -148,6 +177,7 @@ RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Detect if a gam |
|
|
|
RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed |
|
|
|
RLAPI int GetGamepadAxisCount(int gamepad); // Return gamepad axis count for a gamepad |
|
|
|
RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Return axis movement value for a gamepad axis |
|
|
|
RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) |
|
|
|
|
|
|
|
// Input-related functions: mouse |
|
|
|
RLAPI bool IsMouseButtonPressed(int button); // Detect if a mouse button has been pressed once |
|
|
|
@ -161,7 +191,6 @@ RLAPI void SetMousePosition(int x, int y); // Set mouse posit |
|
|
|
RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset |
|
|
|
RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling |
|
|
|
RLAPI float GetMouseWheelMove(void); // Returns mouse wheel movement Y |
|
|
|
RLAPI int GetMouseCursor(void); // Returns mouse cursor if (MouseCursor enum) |
|
|
|
RLAPI void SetMouseCursor(int cursor); // Set mouse cursor |
|
|
|
|
|
|
|
// Input-related functions: touch |
|
|
|
@ -172,30 +201,34 @@ RLAPI Vector2 GetTouchPosition(int index); // Returns touch p |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Gestures and Touch Handling Functions (Module: gestures) |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
RLAPI void SetGesturesEnabled(unsigned int gestureFlags); // Enable a set of gestures using flags |
|
|
|
RLAPI bool IsGestureDetected(int gesture); // Check if a gesture have been detected |
|
|
|
RLAPI int GetGestureDetected(void); // Get latest detected gesture |
|
|
|
RLAPI int GetTouchPointsCount(void); // Get touch points count |
|
|
|
RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds |
|
|
|
RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector |
|
|
|
RLAPI float GetGestureDragAngle(void); // Get gesture drag angle |
|
|
|
RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta |
|
|
|
RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle |
|
|
|
RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags |
|
|
|
RLAPI bool IsGestureDetected(int gesture); // Check if a gesture have been detected |
|
|
|
RLAPI int GetGestureDetected(void); // Get latest detected gesture |
|
|
|
RLAPI int GetTouchPointsCount(void); // Get touch points count |
|
|
|
RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds |
|
|
|
RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector |
|
|
|
RLAPI float GetGestureDragAngle(void); // Get gesture drag angle |
|
|
|
RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta |
|
|
|
RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Camera System Functions (Module: camera) |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
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 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 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) |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Basic Shapes Drawing Functions (Module: shapes) |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Set texture and rectangle to be used on shapes drawing |
|
|
|
// NOTE: It can be useful when using basic shapes and one single font, |
|
|
|
// defining a font char white rectangle would allow drawing everything in a single draw call |
|
|
|
RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing |
|
|
|
|
|
|
|
// Basic shapes drawing functions |
|
|
|
RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel |
|
|
|
@ -204,23 +237,24 @@ RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Colo |
|
|
|
RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version) |
|
|
|
RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness |
|
|
|
RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out |
|
|
|
RLAPI void DrawLineBezierQuad(Vector2 startPos, Vector2 endPos, Vector2 controlPos, float thick, Color color); //Draw line using quadratic bezier curves with a control point |
|
|
|
RLAPI void DrawLineStrip(Vector2 *points, int pointsCount, Color color); // Draw lines sequence |
|
|
|
RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle |
|
|
|
RLAPI void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); // Draw a piece of a circle |
|
|
|
RLAPI void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); // Draw circle sector outline |
|
|
|
RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle |
|
|
|
RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline |
|
|
|
RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle |
|
|
|
RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) |
|
|
|
RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline |
|
|
|
RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse |
|
|
|
RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline |
|
|
|
RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring |
|
|
|
RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring outline |
|
|
|
RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring |
|
|
|
RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline |
|
|
|
RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle |
|
|
|
RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) |
|
|
|
RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle |
|
|
|
RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters |
|
|
|
RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle |
|
|
|
RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle |
|
|
|
RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a vertical-gradient-filled rectangle |
|
|
|
RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2); // Draw a horizontal-gradient-filled rectangle |
|
|
|
RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors |
|
|
|
RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline |
|
|
|
RLAPI void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color); // Draw rectangle outline with extended parameters |
|
|
|
@ -252,7 +286,7 @@ RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); |
|
|
|
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 LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. ".png" |
|
|
|
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 |
|
|
|
@ -321,7 +355,7 @@ RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 posi |
|
|
|
// NOTE: These functions require GPU access |
|
|
|
RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) |
|
|
|
RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data |
|
|
|
RLAPI TextureCubemap LoadTextureCubemap(Image image, int layoutType); // Load cubemap from image, multiple image cubemap layouts supported |
|
|
|
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 void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) |
|
|
|
RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) |
|
|
|
@ -332,18 +366,19 @@ RLAPI Image GetScreenData(void); |
|
|
|
|
|
|
|
// Texture configuration functions |
|
|
|
RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture |
|
|
|
RLAPI void SetTextureFilter(Texture2D texture, int filterMode); // Set texture scaling filter mode |
|
|
|
RLAPI void SetTextureWrap(Texture2D texture, int wrapMode); // Set texture wrapping mode |
|
|
|
RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode |
|
|
|
RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode |
|
|
|
|
|
|
|
// Texture drawing functions |
|
|
|
RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D |
|
|
|
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 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 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 pointsCount, Color tint); // Draw a textured polygon |
|
|
|
|
|
|
|
// Color/pixel related functions |
|
|
|
RLAPI Color Fade(Color color, float alpha); // Returns color with alpha applied, alpha goes from 0.0f to 1.0f |
|
|
|
@ -368,18 +403,17 @@ RLAPI Font GetFontDefault(void); |
|
|
|
RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) |
|
|
|
RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount); // Load font from file with extended parameters |
|
|
|
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 charsCount); // Load font from memory buffer, fileType refers to extension: i.e. "ttf" |
|
|
|
RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int charsCount); // Load font from memory buffer, fileType refers to extension: i.e. ".ttf" |
|
|
|
RLAPI CharInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *fontChars, int charsCount, int type); // Load font data for further use |
|
|
|
RLAPI Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info |
|
|
|
RLAPI void UnloadFontData(CharInfo *chars, int charsCount); // Unload font chars info data (RAM) |
|
|
|
RLAPI void UnloadFont(Font font); // Unload Font from GPU memory (VRAM) |
|
|
|
|
|
|
|
// Text drawing functions |
|
|
|
RLAPI void DrawFPS(int posX, int posY); // Shows current FPS |
|
|
|
RLAPI void DrawFPS(int posX, int posY); // Draw current FPS |
|
|
|
RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) |
|
|
|
RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters |
|
|
|
RLAPI void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint); // Draw text using font inside rectangle limits |
|
|
|
RLAPI void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint, int selectStart, int selectLength, Color selectTint, Color selectBackTint); // Draw text using font inside rectangle limits with support for text selection |
|
|
|
RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) |
|
|
|
|
|
|
|
// Text misc. functions |
|
|
|
@ -435,53 +469,55 @@ RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBott |
|
|
|
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)) |
|
|
|
RLAPI void DrawGizmo(Vector3 position); // Draw simple gizmo |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Model 3d Loading and Drawing Functions (Module: models) |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
|
|
|
|
// Model loading/unloading 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 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 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 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) |
|
|
|
|
|
|
|
// Mesh loading/unloading functions |
|
|
|
RLAPI Mesh *LoadMeshes(const char *fileName, int *meshCount); // Load meshes from model file |
|
|
|
RLAPI void UnloadMesh(Mesh mesh); // Unload mesh from memory (RAM and/or VRAM) |
|
|
|
RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success |
|
|
|
RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload vertex data into GPU and provided VAO/VBO ids |
|
|
|
RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform |
|
|
|
RLAPI void DrawMeshInstanced(Mesh mesh, Material material, Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms |
|
|
|
RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU |
|
|
|
RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success |
|
|
|
|
|
|
|
// 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 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 (MAP_DIFFUSE, MAP_SPECULAR...) |
|
|
|
RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh |
|
|
|
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 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 |
|
|
|
|
|
|
|
// Model animations loading/unloading functions |
|
|
|
RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount); // Load model animations from file |
|
|
|
RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose |
|
|
|
RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data |
|
|
|
RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match |
|
|
|
RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount); // Load model animations from file |
|
|
|
RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose |
|
|
|
RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data |
|
|
|
RLAPI void UnloadModelAnimations(ModelAnimation* animations, unsigned int count); // Unload animation array data |
|
|
|
RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match |
|
|
|
|
|
|
|
// Mesh generation functions |
|
|
|
RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh |
|
|
|
RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) |
|
|
|
RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh |
|
|
|
RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) |
|
|
|
RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) |
|
|
|
RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh |
|
|
|
RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh |
|
|
|
RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh |
|
|
|
RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data |
|
|
|
RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data |
|
|
|
RLAPI Mesh GenMeshDefault(int vertexCount); // Generate an empty mesh with vertex: position, texcoords, normals, colors |
|
|
|
RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh |
|
|
|
RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) |
|
|
|
RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh |
|
|
|
RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) |
|
|
|
RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) |
|
|
|
RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh |
|
|
|
RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh |
|
|
|
RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh |
|
|
|
RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data |
|
|
|
RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data |
|
|
|
|
|
|
|
// Mesh manipulation functions |
|
|
|
RLAPI BoundingBox MeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits |
|
|
|
RLAPI void MeshTangents(Mesh *mesh); // Compute mesh tangents |
|
|
|
RLAPI void MeshBinormals(Mesh *mesh); // Compute mesh binormals |
|
|
|
RLAPI void MeshNormalsSmooth(Mesh *mesh); // Smooth (average) vertex normals |
|
|
|
RLAPI BoundingBox MeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits |
|
|
|
RLAPI void MeshTangents(Mesh *mesh); // Compute mesh tangents |
|
|
|
RLAPI void MeshBinormals(Mesh *mesh); // Compute mesh binormals |
|
|
|
|
|
|
|
// Model drawing functions |
|
|
|
RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) |
|
|
|
@ -504,57 +540,6 @@ RLAPI RayHitInfo GetCollisionRayModel(Ray ray, Model model); |
|
|
|
RLAPI RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle |
|
|
|
RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight); // Get collision info between ray and ground plane (Y-normal plane) |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Shaders System Functions (Module: rlgl) |
|
|
|
// NOTE: This functions are useless when using OpenGL 1.1 |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
|
|
|
|
// Shader loading/unloading functions |
|
|
|
RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations |
|
|
|
RLAPI Shader LoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations |
|
|
|
RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM) |
|
|
|
|
|
|
|
RLAPI Shader GetShaderDefault(void); // Get default shader |
|
|
|
RLAPI Texture2D GetTextureDefault(void); // Get default texture |
|
|
|
RLAPI Texture2D GetShapesTexture(void); // Get texture to draw shapes |
|
|
|
RLAPI Rectangle GetShapesTextureRec(void); // Get texture rectangle to draw shapes |
|
|
|
RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Define default texture used to draw shapes |
|
|
|
|
|
|
|
// Shader configuration functions |
|
|
|
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 uniformLoc, const void *value, int uniformType); // Set shader uniform value |
|
|
|
RLAPI void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count); // Set shader uniform value vector |
|
|
|
RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4) |
|
|
|
RLAPI void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture); // Set shader uniform value for texture |
|
|
|
RLAPI void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix) |
|
|
|
RLAPI void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix) |
|
|
|
RLAPI Matrix GetMatrixModelview(void); // Get internal modelview matrix |
|
|
|
RLAPI Matrix GetMatrixProjection(void); // Get internal projection matrix |
|
|
|
|
|
|
|
// Texture maps generation (PBR) |
|
|
|
// NOTE: Required shaders should be provided |
|
|
|
RLAPI TextureCubemap GenTextureCubemap(Shader shader, Texture2D panorama, int size, int format); // Generate cubemap texture from 2D panorama texture |
|
|
|
RLAPI TextureCubemap GenTextureIrradiance(Shader shader, TextureCubemap cubemap, int size); // Generate irradiance texture using cubemap data |
|
|
|
RLAPI TextureCubemap GenTexturePrefilter(Shader shader, TextureCubemap cubemap, int size); // Generate prefilter texture using cubemap data |
|
|
|
RLAPI Texture2D GenTextureBRDF(Shader shader, int size); // Generate BRDF texture |
|
|
|
|
|
|
|
// Shading begin/end functions |
|
|
|
RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing |
|
|
|
RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader) |
|
|
|
RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied) |
|
|
|
RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending) |
|
|
|
|
|
|
|
// VR control functions |
|
|
|
RLAPI void InitVrSimulator(void); // Init VR simulator for selected device parameters |
|
|
|
RLAPI void CloseVrSimulator(void); // Close VR simulator for current device |
|
|
|
RLAPI void UpdateVrTracking(Camera *camera); // Update VR tracking (position and orientation) and camera |
|
|
|
RLAPI void SetVrConfiguration(VrDeviceInfo info, Shader distortion); // Set stereo rendering configuration parameters |
|
|
|
RLAPI bool IsVrSimulatorReady(void); // Detect if VR simulator is ready |
|
|
|
RLAPI void ToggleVrMode(void); // Enable/Disable VR experience |
|
|
|
RLAPI void BeginVrDrawing(void); // Begin VR simulator stereo rendering |
|
|
|
RLAPI void EndVrDrawing(void); // End VR simulator stereo rendering |
|
|
|
|
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
// Audio Loading and Playing Functions (Module: audio) |
|
|
|
//------------------------------------------------------------------------------------ |
|
|
|
@ -567,10 +552,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 Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. ".wav" |
|
|
|
RLAPI Sound LoadSound(const char *fileName); // Load sound from file |
|
|
|
RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data |
|
|
|
RLAPI void UpdateSound(Sound sound, const void *data, int samplesCount);// Update sound buffer with new data |
|
|
|
RLAPI void UpdateSound(Sound sound, const void *data, int samplesCount); // Update sound buffer with new data |
|
|
|
RLAPI void UnloadWave(Wave wave); // Unload wave data |
|
|
|
RLAPI void UnloadSound(Sound sound); // Unload sound |
|
|
|
RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success |
|
|
|
@ -595,13 +580,14 @@ 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, unsigned char* data, int dataSize); // Load music stream from data |
|
|
|
RLAPI void UnloadMusicStream(Music music); // Unload music stream |
|
|
|
RLAPI void PlayMusicStream(Music music); // Start music playing |
|
|
|
RLAPI bool IsMusicPlaying(Music music); // Check if music is playing |
|
|
|
RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming |
|
|
|
RLAPI void StopMusicStream(Music music); // Stop music playing |
|
|
|
RLAPI void PauseMusicStream(Music music); // Pause music playing |
|
|
|
RLAPI void ResumeMusicStream(Music music); // Resume playing paused music |
|
|
|
RLAPI bool IsMusicPlaying(Music music); // Check if music is playing |
|
|
|
RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) |
|
|
|
RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) |
|
|
|
RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) |
|
|
|
|
Ray
4 years ago