Merge pull request #82 from ChrisDill/3.7-dev

3.7 dev

Physac-cs/Physac.cs

@@ -12,9 +12,9 @@ namespace Physac_cs
         PHYSICS_POLYGON
     }
 
-    // Mat2 type (used for polygon shape rotation matrix)
+    // Matrix2x2 type (used for polygon shape rotation matrix)
     [StructLayout(LayoutKind.Sequential)]
-    public struct Mat2
+    public struct Matrix2x2
     {
         public float m00;
         public float m01;
@@ -64,45 +64,45 @@ namespace Physac_cs
     }
 
     [StructLayout(LayoutKind.Sequential)]
-    public struct PolygonData
+    public struct PhysicsVertexData
     {
-        public uint vertexCount;                           // Current used vertex and normals count
+        public uint vertexCount;                           // Vertex count (positions and normals)
-        public _Polygon_e_FixedBuffer positions;           // Polygon vertex positions vectors
+        public _Polygon_e_FixedBuffer positions;           // Vertex positions vectors
-        public _Polygon_e_FixedBuffer normals;             // Polygon vertex normals vectors
+        public _Polygon_e_FixedBuffer normals;             // Vertex normals vectors
     }
 
     [StructLayout(LayoutKind.Sequential)]
     public struct PhysicsShape
     {
-        public PhysicsShapeType type;                      // Physics shape type (circle or polygon)
+        public PhysicsShapeType type;                      // Shape type (circle or polygon)
         public IntPtr body;                                // Shape physics body reference
-        public float radius;                               // Circle shape radius (used for circle shapes)
+        public PhysicsVertexData vertexData;               // Shape vertices data (used for polygon shapes)
-        public Mat2 transform;                             // Vertices transform matrix 2x2
+        public float radius;                               // Shape radius (used for circle shapes)
-        public PolygonData vertexData;                     // Polygon shape vertices position and normals data (just used for polygon shapes)
+        public Matrix2x2 transform;                        // Vertices transform matrix 2x2
     }
 
     [StructLayout(LayoutKind.Sequential)]
     public struct PhysicsBodyData
     {
-        public uint id;
+        public uint id;                                    // Unique identifier
-        public byte enabled;
+        public byte enabled;                               // Enabled dynamics state (collisions are calculated anyway)
-        public Vector2 position;
+        public Vector2 position;                           // Physics body shape pivot
-        public Vector2 velocity;
+        public Vector2 velocity;                           // Current linear velocity applied to position
-        public Vector2 force;
+        public Vector2 force;                              // Current linear force (reset to 0 every step)
-        public float angularVelocity;
+        public float angularVelocity;                      // Current angular velocity applied to orient
-        public float torque;
+        public float torque;                               // Current angular force (reset to 0 every step)
-        public float orient;
+        public float orient;                               // Rotation in radians
-        public float inertia;
+        public float inertia;                              // Moment of inertia
-        public float inverseInertia;
+        public float inverseInertia;                       // Inverse value of inertia
-        public float mass;
+        public float mass;                                 // Physics body mass
-        public float inverseMass;
+        public float inverseMass;                          // Inverse value of mass
-        public float staticFriction;
+        public float staticFriction;                       // Friction when the body has not movement (0 to 1)
-        public float dynamicFriction;
+        public float dynamicFriction;                      // Friction when the body has movement (0 to 1)
-        public float restitution;
+        public float restitution;                          // Restitution coefficient of the body (0 to 1)
-        public byte useGravity;
+        public byte useGravity;                            // Apply gravity force to dynamics
-        public byte isGrounded;
+        public byte isGrounded;                            // Physics grounded on other body state
-        public byte freezeOrient;
+        public byte freezeOrient;                          // Physics rotation constraint
-        public PhysicsShape shape;
+        public PhysicsShape shape;                         // Physics body shape information (type, radius, vertices, transform)
     }
 
     [StructLayout(LayoutKind.Sequential)]
@@ -136,27 +136,35 @@ namespace Physac_cs
         public const float PHYSAC_PENETRATION_ALLOWANCE = 0.05f;
         public const float PHYSAC_PENETRATION_CORRECTION = 0.4f;
 
+        // Physics system management
+
         // Initializes physics values, pointers and creates physics loop thread
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void InitPhysics();
 
-        // Run physics step, to be used if PHYSICS_NO_THREADS is set in your main loop
+        // Update physics system
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void RunPhysicsStep();
+        public static extern void UpdatePhysics();
+
+        // Reset physics system (global variables)
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ResetPhysics();
+
+        // Close physics system and unload used memory
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void ClosePhysics();
 
         // Sets physics fixed time step in milliseconds. 1.666666 by default
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void SetPhysicsTimeStep(double delta);
 
-        // Returns true if physics thread is currently enabled
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool IsPhysicsEnabled();
-
         // Sets physics global gravity force
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void SetPhysicsGravity(float x, float y);
 
+
+        // Physic body creation/destroy
+
         // Creates a new circle physics body with generic parameters
         // IntPtr refers to a PhysicsBodyData *
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -172,6 +180,13 @@ namespace Physac_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density);
 
+        // Destroy a physics body
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void DestroyPhysicsBody(PhysicsBodyData body);
+
+
+        // Physic body forces
+
         // Adds a force to a physics body
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void PhysicsAddForce(PhysicsBodyData body, Vector2 force);
@@ -184,15 +199,22 @@ namespace Physac_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void PhysicsShatter(PhysicsBodyData body, Vector2 position, float force);
 
-        // Returns the current amount of created physics bodies
+        // Sets physics body shape transform based on radians parameter
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int GetPhysicsBodiesCount();
+        public static extern void SetPhysicsBodyRotation(PhysicsBodyData body, float radians);
+
+
+        // Query physics info
 
         // Returns a physics body of the bodies pool at a specific index
         // IntPtr refers to a PhysicsBodyData *
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr GetPhysicsBody(int index);
 
+        // Returns the current amount of created physics bodies
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern int GetPhysicsBodiesCount();
+
         // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern int GetPhysicsShapeType(int index);
@@ -204,21 +226,5 @@ namespace Physac_cs
         // Returns transformed position of a body shape (body position + vertex transformed position)
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 GetPhysicsShapeVertex(PhysicsBodyData body, int vertex);
-
-        // Sets physics body shape transform based on radians parameter
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void SetPhysicsBodyRotation(PhysicsBodyData body, float radians);
-
-        // Unitializes and destroy a physics body
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void DestroyPhysicsBody(PhysicsBodyData body);
-
-        // Destroys created physics bodies and manifolds and resets global values
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ResetPhysics();
-
-        // Unitializes physics pointers and closes physics loop thread
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void ClosePhysics();
     }
 }

README.md

@@ -2,7 +2,7 @@
 
 # Raylib-cs
 
-C# bindings for raylib 3.5.0, a simple and easy-to-use library to learn videogames programming (www.raylib.com)
+C# bindings for raylib 3.7.0, a simple and easy-to-use library to learn videogames programming (www.raylib.com)
 
 [![GitHub contributors](https://img.shields.io/github/contributors/ChrisDill/Raylib-cs)](https://github.com/ChrisDill/Raylib-cs/graphs/contributors)
 [![License](https://img.shields.io/badge/license-zlib%2Flibpng-blue.svg)](LICENSE)
@@ -16,10 +16,10 @@ Raylib-cs targets netstandard2.1 and supports netcoreapp3.0+ and net5.0.
 
 ## Installation - NuGet
 
-This is the prefered method to get started - The package is still new so please report any [issues](https://github.com/ChrisDill/Raylib-cs/issues). 
+This is the prefered method to get started - The package is still new so please report any [issues](https://github.com/ChrisDill/Raylib-cs/issues).
 
 ```
-dotnet add package Raylib-cs --version 3.5.0
+dotnet add package Raylib-cs --version 3.7.0
 ```
 
 [![NuGet](https://img.shields.io/nuget/dt/raylib-cs)](https://www.nuget.org/packages/Raylib-cs/)
@@ -32,7 +32,7 @@ If you need to edit Raylib-cs source then you will need to add the bindings as a
 
 2. Add Raylib-cs/Raylib-cs.csproj to your project as an existing project.
 
-3. Download the native libraries for the platforms you want to build for using the [official 3.5.0 release](https://github.com/raysan5/raylib/releases/tag/3.5.0).
+3. Download the native libraries for the platforms you want to build for using the [official 3.7.0 release](https://github.com/raysan5/raylib/releases/tag/3.7.0).
    **NOTE: the MSVC version is required for Windows platforms**
 
 4. **(Recommended)** Put the native library for each platform under `Raylib-cs/runtimes/{platform}/native/`

Raygui-cs/Raygui.cs

@@ -34,7 +34,7 @@ namespace Raygui_cs
     }
 
     // Gui standard controls
-    public enum GuiControlStandard
+    public enum GuiControl
     {
         DEFAULT = 0,
         LABEL,          // LABELBUTTON
@@ -185,7 +185,7 @@ namespace Raygui_cs
         // Used by DllImport to load the native library.
         public const string nativeLibName = "raygui";
 
-        public const string RAYGUI_VERSION = "2.6-dev";
+        public const string RAYGUI_VERSION = "2.9-dev";
 
         public const int NUM_CONTROLS = 16;                      // Number of standard controls
         public const int NUM_PROPS_DEFAULT = 16;                 // Number of standard properties
@@ -193,7 +193,7 @@ namespace Raygui_cs
 
         public const int TEXTEDIT_CURSOR_BLINK_FRAMES = 20;      // Text edit controls cursor blink timming
 
-        // Global gui modification functions
+        // State modification functions
 
         // Enable gui controls (global state)
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -223,6 +223,9 @@ namespace Raygui_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiGetState();
 
+
+        // Font set/get functions
+
         // Get gui custom font (global state)
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiSetFont(Font font);
@@ -243,25 +246,6 @@ namespace Raygui_cs
         public static extern int GuiGetStyle(GuiControlStandard control, GuiControlProperty property);
 
 
-        // Tooltips set functions
-
-        // Enable gui tooltips
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void GuiEnableTooltip();
-
-        // Disable gui tooltips
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void GuiDisableTooltip();
-
-        // Set current tooltip for display
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void GuiSetTooltip(string tooltip);
-
-        // Clear any tooltip registered
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void GuiClearTooltip();
-
-
         // Container/separator controls, useful for controls organization
 
         // Window Box control, shows a window that can be closed
@@ -305,12 +289,12 @@ namespace Raygui_cs
         // Image button control, returns true when clicked
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool GuiImageButton(Rectangle bounds, Texture2D texture);
+        public static extern bool GuiImageButton(Rectangle bounds, string text, Texture2D texture);
 
         // Image button extended control, returns true when clicked
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool GuiImageButtonEx(Rectangle bounds, Texture2D texture, Rectangle texSource, string text);
+        public static extern bool GuiImageButtonEx(Rectangle bounds, string text, Texture2D texture, Rectangle texSource);
 
         // Toggle Button control, returns true when active
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -324,7 +308,7 @@ namespace Raygui_cs
         // Check Box control, returns true when active
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool GuiCheckBox(Rectangle bounds, bool isChecked);
+        public static extern bool GuiCheckBox(Rectangle bounds, string text, bool isChecked);
 
         // Combo Box control, returns selected item index
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -333,17 +317,17 @@ namespace Raygui_cs
         // Dropdown Box control, returns selected item
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool GuiDropdownBox(Rectangle bounds, string[] text, ref int active, bool edit);
+        public static extern bool GuiDropdownBox(Rectangle bounds, string text, ref int active, bool editMode);
 
         // Spinner control, returns selected value
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool GuiSpinner(Rectangle bounds, ref int value, int maxValue, int btnWidth);
+        public static extern bool GuiSpinner(Rectangle bounds, string text, ref int value, int minValue, int maxValue, bool editMode);
 
         // Value Box control, updates input text with numbers
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool GuiValueBox(Rectangle bounds, int value, int maxValue);
+        public static extern bool GuiValueBox(Rectangle bounds, string text, ref int value, int minValue, int maxValue, bool editMode);
 
         // Text Box control, updates input text
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -357,15 +341,15 @@ namespace Raygui_cs
 
         // Slider control, returns selected value
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern float GuiSlider(Rectangle bounds, float value, float minValue, float maxValue, bool showValue);
+        public static extern float GuiSlider(Rectangle bounds, string textLeft, string textRight, float value, float minValue, float maxValue);
 
         // Slider Bar control, returns selected value
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern float GuiSliderBar(Rectangle bounds, float value, float minValue, float maxValue, bool showValue);
+        public static extern float GuiSliderBar(Rectangle bounds, float value, float minValue, float maxValue);
 
         // Progress Bar control, shows current progress value
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern float GuiProgressBar(Rectangle bounds, float value, float minValue, float maxValue, bool showValue);
+        public static extern float GuiProgressBar(Rectangle bounds, float value, float minValue, float maxValue);
 
         // Status Bar control, shows info text
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -377,30 +361,30 @@ namespace Raygui_cs
 
         // Scroll Bar control
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue);
+        public static extern int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue);
 
         // Grid
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void GuiGrid(Rectangle bounds, float spacing, int subdivs);
+        public static extern Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs);
 
 
         // Advance controls set
 
         // List View control, returns selected list element index
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int GuiListView(Rectangle bounds, string text, ref int active, ref int scrollIndex, bool editMode);
+        public static extern int GuiListView(Rectangle bounds, string text, ref int scrollIndex, ref int active);
 
         // List View with extended parameters
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int GuiListViewEx(Rectangle bounds, string text, int count, ref int enabled, ref int active, ref int focus, ref int scrollIndex, bool editMode);
+        public static extern int GuiListViewEx(Rectangle bounds, string text, int count, ref int focus, ref int scrollIndex, ref int active);
 
         // Message Box control, displays a message
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int GuiMessageBox(Rectangle bounds, string windowTitle, string message);
+        public static extern int GuiMessageBox(Rectangle bounds, string title, string message);
 
         // Text Input Box control, ask for text
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern int GuiTextInputBox(Rectangle bounds, string windowTitle, string message, string buttons);
+        public static extern int GuiTextInputBox(Rectangle bounds, string windowTitle, string message, string buttons, string text);
 
         // Color Picker control
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -429,25 +413,26 @@ namespace Raygui_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiLoadStyleDefault();
 
-        // Get text with icon id prepended
+        // Get text with icon id prepended (if supported)
-        // Get the human-readable, UTF-8 encoded name of the primary monitor
         [DllImport(nativeLibName, EntryPoint = "GetMonitorName", CallingConvention = CallingConvention.Cdecl)]
         private static extern IntPtr INTERNAL_GuiIconText(int iconId, string text);
         public static string GuiIconText(int iconId, string text)
         {
-            return Marshal.PtrToStringAnsi(INTERNAL_GuiIconText(iconId, text));
+            return Marshal.PtrToStringUTF8(INTERNAL_GuiIconText(iconId, text));
         }
 
 
         // Gui icons functionality
 
         // Get full icons data pointer
+        // IntPtr refers to a unsigned int *
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint[] GuiGetIcons();
+        public static extern IntPtr GuiGetIcons();
 
         // Get icon bit data
+        // IntPtr refers to a unsigned int *
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint[] GuiGetIconData(int iconId, string text);
+        public static extern IntPtr GuiGetIconData(int iconId, string text);
 
         // Set icon bit data
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]

Raylib-cs.Tests/RaylibTests.cs

@@ -36,6 +36,8 @@ namespace Raylib_cs.Tests
             Assert.True(BlittableHelper.IsBlittable<Sound>());
             Assert.True(BlittableHelper.IsBlittable<Music>());
             Assert.True(BlittableHelper.IsBlittable<VrDeviceInfo>());
+            Assert.True(BlittableHelper.IsBlittable<VrStereoConfig>());
+            Assert.True(BlittableHelper.IsBlittable<RenderBatch>());
         }
     }
 }

Raylib-cs/Raylib-cs.csproj

@@ -6,21 +6,23 @@
     <RootNamespace>Raylib_cs</RootNamespace>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
     <GenerateAssemblyInfo>false</GenerateAssemblyInfo>
+    <NoWarn>$(NoWarn);1591</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup>
-    <Version>3.5.0</Version>
+    <Version>3.7.0</Version>
-    <PackageVersion>3.5.0</PackageVersion>
+    <PackageVersion>3.7.0</PackageVersion>
     <Authors>Chris Dill, Raysan5 &amp; Others</Authors>
     <PackProject>true</PackProject>
     <PackageLicenseExpression>Zlib</PackageLicenseExpression>
     <Title>Raylib-cs</Title>
     <Description>C# bindings for raylib - A simple and easy-to-use library to learn videogames programming</Description>
     <PackageIcon>raylib-cs_64x64.png</PackageIcon>
-    <PackageTags>Raylib;Raysan;Games;Game-Engine;Engine;Game</PackageTags>
+    <PackageTags>Raylib;Raysan;Gamedev;Binding</PackageTags>
     <RepositoryType>git</RepositoryType>
     <RepositoryUrl>https://github.com/ChrisDill/Raylib-cs/</RepositoryUrl>
     <PackageProjectUrl>https://www.raylib.com/</PackageProjectUrl>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
   </PropertyGroup>
 
   <ItemGroup>
@@ -31,6 +33,10 @@
     <None Include="../Logo/raylib-cs_64x64.png" Pack="true" PackagePath=""/>
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="System.Numerics.Vectors" Version="4.5.0"/>
+  </ItemGroup>
+
   <ItemGroup>
     <Content Include="runtimes/**" Link="runtimes/%(RecursiveDir)/%(Filename)%(Extension)">
       <PackagePath>runtimes/</PackagePath>

Raylib-cs/Rlgl.cs

@@ -5,9 +5,19 @@ using System.Security;
 
 namespace Raylib_cs
 {
-    // ----------------------------------------------------------------------------------
+    /// <summary>RenderBatch type</summary>
-    // Types and Structures Definition
+    [StructLayout(LayoutKind.Sequential)]
-    // ----------------------------------------------------------------------------------
+    public struct RenderBatch
+    {
+        int buffersCount;           // Number of vertex buffers (multi-buffering support)
+        int currentBuffer;          // Current buffer tracking in case of multi-buffering
+        IntPtr vertexBuffer;        // Dynamic buffer(s) for vertex data
+
+        IntPtr draws;               // Draw calls array, depends on textureId
+        int drawsCounter;           // Draw calls counter
+        float currentDepth;         // Current depth value for next draw
+    }
+
     public enum GlVersion
     {
         OPENGL_11 = 1,
@@ -30,7 +40,7 @@ namespace Raylib_cs
         RL_ATTACHMENT_STENCIL = 200,
     }
 
-    public enum FramebufferTexType
+    public enum FramebufferAttachTextureType
     {
         RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0,
         RL_ATTACHMENT_CUBEMAP_NEGATIVE_X,
@@ -55,61 +65,73 @@ namespace Raylib_cs
         public const int MAX_MATRIX_STACK_SIZE = 32;
         public const float RL_CULL_DISTANCE_NEAR = 0.01f;
         public const float RL_CULL_DISTANCE_FAR = 1000.0f;
+
+        // Texture parameters (equivalent to OpenGL defines)
         public const int RL_TEXTURE_WRAP_S = 0x2802;
         public const int RL_TEXTURE_WRAP_T = 0x2803;
         public const int RL_TEXTURE_MAG_FILTER = 0x2800;
         public const int RL_TEXTURE_MIN_FILTER = 0x2801;
-        public const int RL_TEXTURE_ANISOTROPIC_FILTER = 0x3000;
+
-        public const int RL_FILTER_NEAREST = 0x2600;
+        public const int RL_TEXTURE_FILTER_NEAREST = 0x2600;
-        public const int RL_FILTER_LINEAR = 0x2601;
+        public const int RL_TEXTURE_FILTER_LINEAR = 0x2601;
-        public const int RL_FILTER_MIP_NEAREST = 0x2700;
+        public const int RL_TEXTURE_FILTER_MIP_NEAREST = 0x2700;
-        public const int RL_FILTER_NEAREST_MIP_LINEAR = 0x2702;
+        public const int RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR = 0x2702;
-        public const int RL_FILTER_LINEAR_MIP_NEAREST = 0x2701;
+        public const int RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST = 0x2701;
-        public const int RL_FILTER_MIP_LINEAR = 0x2703;
+        public const int RL_TEXTURE_FILTER_MIP_LINEAR = 0x2703;
-        public const int RL_WRAP_REPEAT = 0x2901;
+        public const int RL_TEXTURE_FILTER_ANISOTROPIC = 0x3000;
-        public const int RL_WRAP_CLAMP = 0x812F;
+
-        public const int RL_WRAP_MIRROR_REPEAT = 0x8370;
+        public const int RL_TEXTURE_WRAP_REPEAT = 0x2901;
-        public const int RL_WRAP_MIRROR_CLAMP = 0x8742;
+        public const int RL_TEXTURE_WRAP_CLAMP = 0x812F;
+        public const int RL_TEXTURE_WRAP_MIRROR_REPEAT = 0x8370;
+        public const int RL_TEXTURE_WRAP_MIRROR_CLAMP = 0x8742;
+
+        // Matrix modes (equivalent to OpenGL)
         public const int RL_MODELVIEW = 0x1700;
         public const int RL_PROJECTION = 0x1701;
         public const int RL_TEXTURE = 0x1702;
+
+        // Primitive assembly draw modes
         public const int RL_LINES = 0x0001;
         public const int RL_TRIANGLES = 0x0004;
         public const int RL_QUADS = 0x0007;
 
+        // GL equivalent data types
+        public const int RL_UNSIGNED_BYTE = 0x1401;
+        public const int RL_FLOAT = 0x1406;
+
         // ------------------------------------------------------------------------------------
         // Functions Declaration - Matrix operations
         // ------------------------------------------------------------------------------------
 
-        // Choose the current matrix to be transformed
+        /// <summary>Choose the current matrix to be transformed</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlMatrixMode(int mode);
 
-        // Push the current matrix to stack
+        /// <summary>Push the current matrix to stack</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlPushMatrix();
 
-        // Pop lattest inserted matrix from stack
+        /// <summary>Pop lattest inserted matrix from stack</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlPopMatrix();
 
-        // Reset current matrix to identity matrix
+        /// <summary>Reset current matrix to identity matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlLoadIdentity();
 
-        // Multiply the current matrix by a translation matrix
+        /// <summary>Multiply the current matrix by a translation matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlTranslatef(float x, float y, float z);
 
-        // Multiply the current matrix by a rotation matrix
+        /// <summary>Multiply the current matrix by a rotation matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlRotatef(float angleDeg, float x, float y, float z);
 
-        // Multiply the current matrix by a scaling matrix
+        /// <summary>Multiply the current matrix by a scaling matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlScalef(float x, float y, float z);
 
-        // Multiply the current matrix by another matrix
+        /// <summary>Multiply the current matrix by another matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlMultMatrixf(ref float[] matf);
 
@@ -119,286 +141,514 @@ namespace Raylib_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
 
-        // Set the viewport area
+        /// <summary>Set the viewport area</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlViewport(int x, int y, int width, int height);
 
+
         // ------------------------------------------------------------------------------------
         // Functions Declaration - Vertex level operations
         // ------------------------------------------------------------------------------------
 
-        // Initialize drawing mode (how to organize vertex)
+        /// <summary>Initialize drawing mode (how to organize vertex)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlBegin(int mode);
 
-        // Finish vertex providing
+        /// <summary>Finish vertex providing</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnd();
 
-        // Define one vertex (position) - 2 int
+        /// <summary>Define one vertex (position) - 2 int</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlVertex2i(int x, int y);
 
-        // Define one vertex (position) - 2 float
+        /// <summary>Define one vertex (position) - 2 float</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlVertex2f(float x, float y);
 
-        // Define one vertex (position) - 3 float
+        /// <summary>Define one vertex (position) - 3 float</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlVertex3f(float x, float y, float z);
 
-        // Define one vertex (texture coordinate) - 2 float
+        /// <summary>Define one vertex (texture coordinate) - 2 float</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlTexCoord2f(float x, float y);
 
-        // Define one vertex (normal) - 3 float
+        /// <summary>Define one vertex (normal) - 3 float</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlNormal3f(float x, float y, float z);
 
-        // Define one vertex (color) - 4 byte
+        /// <summary>Define one vertex (color) - 4 byte</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlColor4ub(byte r, byte g, byte b, byte a);
 
-        // Define one vertex (color) - 3 float
+        /// <summary>Define one vertex (color) - 3 float</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlColor3f(float x, float y, float z);
 
-        // Define one vertex (color) - 4 float
+        /// <summary>Define one vertex (color) - 4 float</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlColor4f(float x, float y, float z, float w);
 
+
         // ------------------------------------------------------------------------------------
         // Functions Declaration - OpenGL equivalent functions (common to 1.1, 3.3+, ES2)
         // NOTE: This functions are used to completely abstract raylib code from OpenGL layer
         // ------------------------------------------------------------------------------------
 
-        // Enable texture usage
+        /// <summary>Vertex buffers state</summary>
+
+        /// <summary>Enable vertex array (VAO, if supported)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool rlEnableVertexArray(uint vaoId);
+
+        /// <summary>Disable vertex array (VAO, if supported)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableVertexArray();
+
+        /// <summary>Enable vertex buffer (VBO)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlEnableVertexBuffer(uint id);
+
+        /// <summary>Disable vertex buffer (VBO)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableVertexBuffer();
+
+        /// <summary>Enable vertex buffer element (VBO element)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlEnableVertexBufferElement(uint id);
+
+        /// <summary>Disable vertex buffer element (VBO element)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableVertexBufferElement();
+
+        /// <summary>Enable vertex attribute index</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlEnableVertexAttribute(uint index);
+
+        /// <summary>Disable vertex attribute index</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableVertexAttribute(uint index);
+
+
+        // Textures state
+
+        /// <summary>Select and active a texture slot</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlActiveTextureSlot(int slot);
+
+        /// <summary>Enable texture</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableTexture(uint id);
 
-        // Disable texture usage
+        /// <summary>Disable texture</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableTexture();
 
-        // Set texture parameters (filter, wrap)
+        /// <summary>Enable texture cubemap</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlEnableTextureCubemap(uint id);
+
+        /// <summary>Disable texture cubemap</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableTextureCubemap();
+
+        /// <summary>Set texture parameters (filter, wrap)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlTextureParameters(uint id, int param, int value);
 
-        // Enable render texture (fbo)
+
+        // Shader state
+
+        /// <summary>Enable shader program</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlEnableShader(uint id);
+
+        /// <summary>Disable shader program</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableShader();
+
+
+        // Framebuffer state
+
+        /// <summary>Enable render texture (fbo)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableFramebuffer(uint id);
 
-        // Disable render texture (fbo), return to default framebuffer
+        /// <summary>Disable render texture (fbo), return to default framebuffer</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableFramebuffer();
 
-        // Enable depth test
+
+        // General render state
+
+        /// <summary>Enable depth test</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableDepthTest();
 
-        // Disable depth test
+        /// <summary>Disable depth test</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableDepthTest();
 
-        // Enable depth write
+        /// <summary>Enable depth write</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableDepthMask();
 
-        // Disable depth write
+        /// <summary>Disable depth write</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableDepthMask();
 
-        // Enable backface culling
+        /// <summary>Enable backface culling</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableBackfaceCulling();
 
-        // Disable backface culling
+        /// <summary>Disable backface culling</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableBackfaceCulling();
 
-        // Enable scissor test
+        /// <summary>Enable scissor test</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableScissorTest();
 
-        // Disable scissor test
+        /// <summary>Disable scissor test</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableScissorTest();
 
-        // Scissor test
+        /// <summary>Scissor test</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlScissor(int x, int y, int width, int height);
 
-        // Enable wire mode
+        /// <summary>Enable wire mode</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableWireMode();
 
-        // Disable wire mode
+        /// <summary>Disable wire mode</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableWireMode();
 
-        // Set the line drawing width
+        /// <summary>Set the line drawing width</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlSetLineWidth(float width);
 
-        // Get the line drawing width
+        /// <summary>Get the line drawing width</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern float rlGetLineWidth();
 
-        // Enable line aliasing
+        /// <summary>Enable line aliasing</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableSmoothLines();
 
-        // Disable line aliasing
+        /// <summary>Disable line aliasing</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableSmoothLines();
 
-        // Clear color buffer with color
+        /// <summary>Enable stereo rendering</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlEnableStereoRender();
+
+        /// <summary>Disable stereo rendering</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDisableStereoRender();
+
+        /// <summary>Check if stereo render is enabled</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        [return: MarshalAs(UnmanagedType.I1)]
+        public static extern bool rlIsStereoRenderEnabled();
+
+        /// <summary>Clear color buffer with color</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlClearColor(byte r, byte g, byte b, byte a);
 
-        // Clear used screen buffers (color and depth)
+        /// <summary>Clear used screen buffers (color and depth)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlClearScreenBuffers();
 
-        // Update GPU buffer with new data
+        /// <summary>Check and log OpenGL error codes</summary>
-        // data refers to a void *
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlUpdateBuffer(int bufferId, IntPtr data, int dataSize);
+        public static extern void rlCheckErrors();
 
-        // Load a new attributes buffer
+        /// <summary>Set blending mode</summary>
-        // buffer refers to a void *
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint rlLoadAttribBuffer(uint vaoId, int shaderLoc, IntPtr buffer, int size, bool dynamic);
+        public static extern void rlSetBlendMode(int mode);
+
+        /// <summary>Set blending mode factor and equation (using OpenGL factors)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetBlendModeFactors(int glSrcFactor, int glDstFactor, int glEquation);
+
 
         // ------------------------------------------------------------------------------------
         // Functions Declaration - rlgl functionality
         // ------------------------------------------------------------------------------------
 
-        // Initialize rlgl (buffers, shaders, textures, states)
+        /// <summary>Initialize rlgl (buffers, shaders, textures, states)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlglInit(int width, int height);
 
-        // De-inititialize rlgl (buffers, shaders, textures)
+        /// <summary>De-inititialize rlgl (buffers, shaders, textures)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlglClose();
 
-        // Update and draw default internal buffers
+        /// <summary>Load OpenGL extensions</summary>
+        /// <summary>loader refers to a void *</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlglDraw();
+        public static extern void rlLoadExtensions(IntPtr loader);
 
-        // Check and log OpenGL error codes
+        /// <summary>Returns current OpenGL version</summary>
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlCheckErrors();
-
-        // Returns current OpenGL version
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern GlVersion rlGetVersion();
 
-        // Check internal buffer overflow for a given number of vertex
+        /// <summary>Get default framebuffer width</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern int rlGetFramebufferWidth();
+
+        /// <summary>Get default framebuffer height</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern int rlGetFramebufferHeight();
+
+        /// <summary>Get default shader</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Shader rlGetShaderDefault();
+
+        /// <summary>Get default texture</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Texture2D rlGetTextureDefault();
+
+
+        // Render batch management
+
+        /// <summary>Load a render batch system</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern RenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements);
+
+        /// <summary>Unload render batch system</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlUnloadRenderBatch(RenderBatch batch);
+
+        /// <summary>Draw render batch data (Update->Draw->Reset)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDrawRenderBatch(ref RenderBatch batch);
+
+        /// <summary>Set the active render batch for rlgl (NULL for default internal)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetRenderBatchActive(ref RenderBatch batch);
+
+        /// <summary>Update and draw internal render batch</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDrawRenderBatchActive();
+
+        /// <summary>Check internal buffer overflow for a given number of vertex</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
-        public static extern bool rlCheckBufferLimit(int vCount);
+        public static extern bool rlCheckRenderBatchLimit(int vCount);
 
-        // Set debug marker for analysis
+        /// <summary>Set current texture for render batch and check buffers limits</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlSetDebugMarker(string text);
+        public static extern void rlSetTexture(uint id);
 
-        // Set blending mode factor and equation (using OpenGL factors)
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlSetBlendMode(int glSrcFactor, int glDstFactor, int glEquation);
 
-        // Load OpenGL extensions
+        // Vertex buffers management
-        // loader refers to a void *
+
+        /// <summary>Load vertex array (vao) if supported</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlLoadExtensions(IntPtr loader);
+        public static extern uint rlLoadVertexArray();
+
+        /// <summary>Load a vertex buffer attribute</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern uint rlLoadVertexBuffer(IntPtr buffer, int size, bool dynamic);
+
+        /// <summary>Load a new attributes element buffer</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern uint rlLoadVertexBufferElement(IntPtr buffer, int size, bool dynamic);
+
+        /// <summary>Update GPU buffer with new data</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlUpdateVertexBuffer(int bufferId, IntPtr data, int dataSize, int offset);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlUnloadVertexArray(uint vaoId);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlUnloadVertexBuffer(uint vboId);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetVertexAttribute(uint index, int compSize, int type, bool normalized, int stride, IntPtr pointer);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetVertexAttributeDivisor(uint index, int divisor);
+
+        /// <summary>Set vertex attribute default value</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetVertexAttributeDefault(int locIndex, IntPtr value, int attribType, int count);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDrawVertexArray(int offset, int count);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDrawVertexArrayElements(int offset, int count, IntPtr buffer);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDrawVertexArrayInstanced(int offset, int count, int instances);
+
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlDrawVertexArrayElementsInstanced(int offset, int count, IntPtr buffer, int instances);
 
 
         // Textures data management
 
-        // Load texture in GPU
+        /// <summary>Load texture in GPU
-        // data refers to a void *
+        /// data refers to a void *</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern uint rlLoadTexture(IntPtr data, int width, int height, PixelFormat format, int mipmapCount);
 
-        // Load depth texture/renderbuffer (to be attached to fbo)
+        /// <summary>Load depth texture/renderbuffer (to be attached to fbo)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint rlLoadTextureDepth(int width, int height, int bits, bool useRenderBuffer);
+        public static extern uint rlLoadTextureDepth(int width, int height, bool useRenderBuffer);
 
-        // Load texture cubemap
+        /// <summary>Load texture cubemap
-        // data refers to a void *
+        /// data refers to a void *</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern uint rlLoadTextureCubemap(IntPtr data, int size, PixelFormat format);
 
-        // Update GPU texture with new data
+        /// <summary>Update GPU texture with new data
-        // data refers to a const void *
+        /// data refers to a const void *</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlUpdateTexture(uint id, int width, int height, PixelFormat format, IntPtr data);
 
-        // Get OpenGL internal formats
+        /// <summary>Get OpenGL internal formats</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlGetGlTextureFormats(PixelFormat format, ref uint glInternalFormat, ref uint glFormat, ref uint glType);
 
-        // Unload texture from GPU memory
+        /// <summary>Unload texture from GPU memory</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlUnloadTexture(uint id);
 
-        // Generate mipmap data for selected texture
+        /// <summary>Generate mipmap data for selected texture</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlGenerateMipmaps(ref Texture2D texture);
 
-        // Read texture pixel data
+        /// <summary>Read texture pixel data
-        // IntPtr refers to a void *
+        /// IntPtr refers to a void *</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern IntPtr rlReadTexturePixels(Texture2D texture);
 
-        // Read screen pixel data (color buffer)
+        /// <summary>Read screen pixel data (color buffer)
+        /// IntPtr refers to a unsigned char *</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern byte[] rlReadScreenPixels(int width, int height);
+        public static extern IntPtr rlReadScreenPixels(int width, int height);
 
 
         // Framebuffer management (fbo)
 
-        // Load an empty framebuffer
+        /// <summary>Load an empty framebuffer</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern uint rlLoadFramebuffer(int width, int height);
 
-        // Attach texture/renderbuffer to a framebuffer
+        /// <summary>Attach texture/renderbuffer to a framebuffer</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlFramebufferAttach(uint fboId, uint texId, FramebufferAttachType attachType, FramebufferTexType texType);
+        public static extern void rlFramebufferAttach(uint fboId, uint texId, FramebufferAttachType attachType, FramebufferAttachTextureType texType, int mipLevel);
 
-        // Verify framebuffer is complete
+        /// <summary>Verify framebuffer is complete</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
         public static extern bool rlFramebufferComplete(uint id);
 
-        // Delete framebuffer from GPU
+        /// <summary>Delete framebuffer from GPU</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         [return: MarshalAs(UnmanagedType.I1)]
         public static extern bool rlUnloadFramebuffer(uint id);
 
-        // Vertex data management
-        // Upload vertex data into GPU and provided VAO/VBO ids
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlLoadMesh(ref Mesh mesh, bool dynamic);
 
-        // Update vertex or index data on GPU (upload new data to one buffer)
+        // Shaders management
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlUpdateMesh(Mesh mesh, int buffer, int num);
 
-        // Update vertex or index data on GPU, at index
+        /// <summary>Load shader from code strings</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlUpdateMeshAt(Mesh mesh, int buffer, int num, int index);
+        public static extern uint rlLoadShaderCode(string vsCode, string fsCode);
 
-        // Draw a 3d mesh with material and transform
+        /// <summary>Compile custom shader and return shader id (type: GL_VERTEX_SHADER, GL_FRAGMENT_SHADER)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlDrawMesh(Mesh mesh, Material material, Matrix4x4 transform);
+        public static extern uint rlCompileShader(string shaderCode, int type);
 
-        // Draw a 3d mesh with material and transform
+        /// <summary>Load custom shader program</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlDrawMeshInstanced(Mesh mesh, Material material, Matrix4x4[] transforms, int count);
+        public static extern uint rlLoadShaderProgram(uint vShaderId, uint fShaderId);
 
-        // Unload mesh data from CPU and GPU
+        /// <summary>Unload shader program</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlUnloadMesh(Mesh mesh);
+        public static extern void rlUnloadShaderProgram(uint id);
+
+        /// <summary>Get shader location uniform</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern int rlGetLocationUniform(uint shaderId, string uniformName);
+
+        /// <summary>Get shader location attribute</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern int rlGetLocationAttrib(uint shaderId, string attribName);
+
+        /// <summary>Set shader value uniform</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetUniform(int locIndex, IntPtr value, int uniformType, int count);
+
+        /// <summary>Set shader value matrix</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetUniformMatrix(int locIndex, Matrix4x4 mat);
+
+        /// <summary>Set shader value sampler</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetUniformSampler(int locIndex, uint textureId);
+
+        /// <summary>Set shader currently active</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetShader(Shader shader);
+
+
+        // Matrix state management
+
+        /// <summary>Get internal modelview matrix</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Matrix4x4 rlGetMatrixModelView();
+
+        /// <summary>Get internal projection matrix</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Matrix4x4 rlGetMatrixProjection();
+
+        /// <summary>Get internal accumulated transform matrix</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Matrix4x4 rlGetMatrixTramsform();
+
+        /// <summary>Get internal projection matrix for stereo render (selected eye)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Matrix4x4 rlGetMatrixProjectionStereo(int eye);
+
+        /// <summary>Get internal view offset matrix for stereo render (selected eye)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern Matrix4x4 rlGetMatrixViewOffsetStereo(int eye);
+
+        /// <summary>Set a custom projection matrix (replaces internal projection matrix)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetMatrixProjection(Matrix4x4 view);
+
+        /// <summary>Set a custom modelview matrix (replaces internal modelview matrix)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetMatrixModelView(Matrix4x4 proj);
+
+        /// <summary>Set eyes projection matrices for stereo rendering</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetMatrixProjectionStereo(Matrix4x4 left, Matrix4x4 right);
+
+        /// <summary>Set eyes view offsets matrices for stereo rendering</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetMatrixViewOffsetStereo(Matrix4x4 left, Matrix4x4 right);
+
+
+        // Quick and dirty cube/quad buffers load->draw->unload
+
+        /// <summary>Load and draw a cube</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlLoadDrawCube();
+
+        /// <summary>Load and draw a quad</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlLoadDrawQuad();
     }
 }