Update to raylib 4.5 (#149)

* Update bindings to raylib 4.5
* Review naming, comments and formatting

Raylib-cs/interop/Raymath.cs

@@ -37,7 +37,13 @@ namespace Raylib_cs
 
         /// <summary>Remap input value within input range to output range</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern float Remap(float value, float inputStart, float inputEnd, float outputStart, float outputEnd);
+        public static extern float Remap(
+            float value,
+            float inputStart,
+            float inputEnd,
+            float outputStart,
+            float outputEnd
+        );
 
         /// <summary>Wrap input value from min to max</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -91,10 +97,21 @@ namespace Raylib_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector2DistanceSqr(Vector2 v1, Vector2 v2);
 
-        /// <summary>Calculate angle from two vectors</summary>
+        /// <summary>
+        /// Calculate angle between two vectors
+        /// NOTE: Angle is calculated from origin point (0, 0)
+        /// </summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector2Angle(Vector2 v1, Vector2 v2);
 
+        /// <summary>
+        /// Calculate angle defined by a two vectors line
+        /// NOTE: Parameters need to be normalized
+        /// Current implementation should be aligned with glm::angle
+        /// </summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern float Vector2LineAngle(Vector2 start, Vector2 end);
+
         /// <summary>Scale vector (multiply by value)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Scale(Vector2 v, float scale);
@@ -387,7 +404,14 @@ namespace Raylib_cs
 
         /// <summary>Get perspective projection matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern Matrix4x4 MatrixFrustum(double left, double right, double bottom, double top, double near, double far);
+        public static extern Matrix4x4 MatrixFrustum(
+            double left,
+            double right,
+            double bottom,
+            double top,
+            double near,
+            double far
+        );
 
         /// <summary>
         /// Get perspective projection matrix<br/>
@@ -398,7 +422,14 @@ namespace Raylib_cs
 
         /// <summary>Get orthographic projection matrix</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern Matrix4x4 MatrixOrtho(double left, double right, double bottom, double top, double near, double far);
+        public static extern Matrix4x4 MatrixOrtho(
+            double left,
+            double right,
+            double bottom,
+            double top,
+            double near,
+            double far
+        );
 
         /// <summary>Get camera look-at matrix (view matrix)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]

Raylib-cs/interop/Rlgl.cs

@@ -33,13 +33,13 @@ namespace Raylib_cs
         public const int RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST = 0x2701;
         public const int RL_TEXTURE_FILTER_MIP_LINEAR = 0x2703;
         public const int RL_TEXTURE_FILTER_ANISOTROPIC = 0x3000;
+        public const int RL_TEXTURE_MIPMAP_BIAS_RATIO = 0x4000;
 
         public const int RL_TEXTURE_WRAP_REPEAT = 0x2901;
         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;
 
-
         // GL equivalent data types
         public const int RL_UNSIGNED_BYTE = 0x1401;
         public const int RL_FLOAT = 0x1406;
@@ -55,6 +55,37 @@ namespace Raylib_cs
         public const int RL_DYNAMIC_READ = 0x88E9;
         public const int RL_DYNAMIC_COPY = 0x88EA;
 
+        // GL blending factors
+        public const int RL_ZERO = 0;
+        public const int RL_ONE = 1;
+        public const int RL_SRC_COLOR = 0x0300;
+        public const int RL_ONE_MINUS_SRC_COLOR = 0x0301;
+        public const int RL_SRC_ALPHA = 0x0302;
+        public const int RL_ONE_MINUS_SRC_ALPHA = 0x0303;
+        public const int RL_DST_ALPHA = 0x0304;
+        public const int RL_ONE_MINUS_DST_ALPHA = 0x0305;
+        public const int RL_DST_COLOR = 0x0306;
+        public const int RL_ONE_MINUS_DST_COLOR = 0x0307;
+        public const int RL_SRC_ALPHA_SATURATE = 0x0308;
+        public const int RL_CONSTANT_COLOR = 0x8001;
+        public const int RL_ONE_MINUS_CONSTANT_COLOR = 0x8002;
+        public const int RL_CONSTANT_ALPHA = 0x8003;
+        public const int RL_ONE_MINUS_CONSTANT_ALPHA = 0x8004;
+
+        // GL blending functions/equations
+        public const int RL_FUNC_ADD = 0x8006;
+        public const int RL_MIN = 0x8007;
+        public const int RL_MAX = 0x8008;
+        public const int RL_FUNC_SUBTRACT = 0x800A;
+        public const int RL_FUNC_REVERSE_SUBTRACT = 0x800B;
+        public const int RL_BLEND_EQUATION = 0x8009;
+        public const int RL_BLEND_EQUATION_RGB = 0x8009;
+        public const int RL_BLEND_EQUATION_ALPHA = 0x883D;
+        public const int RL_BLEND_DST_RGB = 0x80C8;
+        public const int RL_BLEND_SRC_RGB = 0x80C9;
+        public const int RL_BLEND_DST_ALPHA = 0x80CA;
+        public const int RL_BLEND_SRC_ALPHA = 0x80CB;
+        public const int RL_BLEND_COLOR = 0x8005;
 
         // ------------------------------------------------------------------------------------
         // Functions Declaration - Matrix operations
@@ -109,10 +140,24 @@ namespace Raylib_cs
         }
 
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
+        public static extern void rlFrustum(
+            double left,
+            double right,
+            double bottom,
+            double top,
+            double znear,
+            double zfar
+        );
 
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
+        public static extern void rlOrtho(
+            double left,
+            double right,
+            double bottom,
+            double top,
+            double znear,
+            double zfar
+        );
 
         /// <summary>Set the viewport area</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -245,6 +290,10 @@ namespace Raylib_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlTextureParameters(uint id, int param, int value);
 
+        /// <summary>Set cubemap parameters (filter, wrap)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlCubemapParameters(uint id, int param, int value);
+
 
         // Shader state
 
@@ -306,6 +355,10 @@ namespace Raylib_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlDisableBackfaceCulling();
 
+        /// <summary>Set face culling mode</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetCullFace(int mode);
+
         /// <summary>Enable scissor test</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlEnableScissorTest();
@@ -374,6 +427,17 @@ namespace Raylib_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation);
 
+        /// <summary>Set blending mode factors and equations separately (using OpenGL factors)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlSetBlendFactorsSeparate(
+            int glSrcRGB,
+            int glDstRGB,
+            int glSrcAlpha,
+            int glDstAlpha,
+            int glEqRGB,
+            int glEqAlpha
+        );
+
 
         // ------------------------------------------------------------------------------------
         // Functions Declaration - rlgl functionality
@@ -477,7 +541,14 @@ namespace Raylib_cs
         public static extern void rlUnloadVertexBuffer(uint vboId);
 
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlSetVertexAttribute(uint index, int compSize, int type, CBool normalized, int stride, void* pointer);
+        public static extern void rlSetVertexAttribute(
+            uint index,
+            int compSize,
+            int type,
+            CBool normalized,
+            int stride,
+            void* pointer
+        );
 
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlSetVertexAttributeDivisor(uint index, int divisor);
@@ -496,7 +567,12 @@ namespace Raylib_cs
         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, void* buffer, int instances);
+        public static extern void rlDrawVertexArrayElementsInstanced(
+            int offset,
+            int count,
+            void* buffer,
+            int instances
+        );
 
 
         // Textures data management
@@ -515,11 +591,24 @@ namespace Raylib_cs
 
         /// <summary>Update GPU texture with new data</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlUpdateTexture(uint id, int offsetX, int offsetY, int width, int height, PixelFormat format, void* data);
+        public static extern void rlUpdateTexture(
+            uint id,
+            int offsetX,
+            int offsetY,
+            int width,
+            int height,
+            PixelFormat format,
+            void* data
+        );
 
         /// <summary>Get OpenGL internal formats</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlGetGlTextureFormats(PixelFormat format, int* glInternalFormat, int* glFormat, int* glType);
+        public static extern void rlGetGlTextureFormats(
+            PixelFormat format,
+            int* glInternalFormat,
+            int* glFormat,
+            int* glType
+        );
 
         /// <summary>Get OpenGL internal formats</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -550,7 +639,13 @@ namespace Raylib_cs
 
         /// <summary>Attach texture/renderbuffer to a framebuffer</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlFramebufferAttach(uint fboId, uint texId, FramebufferAttachType attachType, FramebufferAttachTextureType texType, int mipLevel);
+        public static extern void rlFramebufferAttach(
+            uint fboId,
+            uint texId,
+            FramebufferAttachType attachType,
+            FramebufferAttachTextureType texType,
+            int mipLevel
+        );
 
         /// <summary>Verify framebuffer is complete</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -558,7 +653,7 @@ namespace Raylib_cs
 
         /// <summary>Delete framebuffer from GPU</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern CBool rlUnloadFramebuffer(uint id);
+        public static extern void rlUnloadFramebuffer(uint id);
 
 
         // Shaders management
@@ -615,9 +710,12 @@ namespace Raylib_cs
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
         public static extern void rlComputeShaderDispatch(uint groupX, uint groupY, uint groupZ);
 
+
+        // Shader buffer storage object management (ssbo)
+
         /// <summary>Load shader storage buffer object (SSBO)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern uint rlLoadShaderBuffer(ulong size, void* data, int usageHint);
+        public static extern uint rlLoadShaderBuffer(uint size, void* data, int usageHint);
 
         /// <summary>Unload shader storage buffer object (SSBO)</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
@@ -625,30 +723,36 @@ namespace Raylib_cs
 
         /// <summary>Update SSBO buffer data</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlUpdateShaderBufferElements(uint id, void* data, ulong dataSize, ulong offset);
+        public static extern void rlUpdateShaderBuffer(uint id, void* data, uint dataSize, uint offset);
+
+        /// <summary>Bind SSBO buffer data</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlBindShaderBuffer(uint id, uint index);
+
+        /// <summary>Read SSBO buffer data (GPU->CPU)</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlReadShaderBuffer(uint id, void* dest, uint count, uint offset);
+
+        /// <summary>Copy SSBO data between buffers</summary>
+        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
+        public static extern void rlCopyShaderBuffer(
+            uint destId,
+            uint srcId,
+            uint destOffset,
+            uint srcOffset,
+            uint count
+        );
 
         /// <summary>Get SSBO buffer size</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern ulong rlGetShaderBufferSize(uint id, void* dest, ulong count, ulong offset);
+        public static extern uint rlGetShaderBufferSize(uint id);
-
-        /// <summary>Bind SSBO buffer</summary>
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlReadShaderBufferElements(uint id, void* dest, ulong count, ulong offset);
-
-        /// <summary> Copy SSBO buffer data</summary>
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlBindShaderBuffer(uint id, uint index);
 
 
         // Buffer management
 
-        /// <summary>Copy SSBO buffer data</summary>
-        [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlCopyBuffersElements(uint destId, uint srcId, ulong destOffset, ulong srcOffset, ulong count);
-
         /// <summary>Bind image texture</summary>
         [DllImport(nativeLibName, CallingConvention = CallingConvention.Cdecl)]
-        public static extern void rlBindImageTexture(uint id, uint index, uint format, int readOnly);
+        public static extern void rlBindImageTexture(uint id, uint index, int format, CBool readOnly);
 
 
         // Matrix state management

Raylib-cs/types/Core.cs

@@ -169,8 +169,13 @@ namespace Raylib_cs
         BLEND_ALPHA_PREMULTIPLY,
 
         /// <summary>
-        /// Blend textures using custom src/dst factors (use rlSetBlendMode())
+        /// Blend textures using custom src/dst factors (use rlSetBlendFactors())
         /// </summary>
-        BLEND_CUSTOM
+        BLEND_CUSTOM,
+
+        /// <summary>
+        /// Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate())
+        /// </summary>
+        BLEND_CUSTOM_SEPARATE
     }
 }

Raylib-cs/types/Input.cs

@@ -229,7 +229,7 @@ namespace Raylib_cs
         MOUSE_CURSOR_RESIZE_NESW = 8,
 
         /// <summary>
-        /// The omni-directional resize/move cursor shape
+        /// The omnidirectional resize/move cursor shape
         /// </summary>
         MOUSE_CURSOR_RESIZE_ALL = 9,
 
@@ -332,12 +332,12 @@ namespace Raylib_cs
         /// Gamepad top/back trigger left (second), it could be a trailing button
         /// </summary>
         GAMEPAD_BUTTON_LEFT_TRIGGER_2,
-        
+
         /// <summary>
         /// Gamepad top/back trigger right (first), it could be a trailing button
         /// </summary>
         GAMEPAD_BUTTON_RIGHT_TRIGGER_1,
-        
+
         /// <summary>
         /// Gamepad top/back trigger right (second), it could be a trailing button
         /// </summary>

Raylib-cs/types/Ray.cs

@@ -38,12 +38,12 @@ namespace Raylib_cs
         public CBool hit;
 
         /// <summary>
-        /// Distance to nearest hit
+        /// Distance to the nearest hit
         /// </summary>
         public float distance;
 
         /// <summary>
-        /// Position of nearest hit
+        /// Point of the nearest hit
         /// </summary>
         public Vector3 point;
 

Raylib-cs/types/Raylib.Utils.cs

@@ -137,43 +137,61 @@ namespace Raylib_cs
         }
 
         /// <summary>Set shader uniform value vector</summary>
-        public static void SetShaderValueV<T>(Shader shader, int uniformLoc, T[] values, ShaderUniformDataType uniformType, int count)
+        public static void SetShaderValueV<T>(
-        where T : unmanaged
+            Shader shader,
+            int locIndex,
+            T[] values,
+            ShaderUniformDataType uniformType,
+            int count
+        ) where T : unmanaged
         {
-            SetShaderValueV(shader, uniformLoc, (Span<T>)values, uniformType, count);
+            SetShaderValueV(shader, locIndex, (Span<T>)values, uniformType, count);
         }
 
         /// <summary>Set shader uniform value vector</summary>
-        public static void SetShaderValueV<T>(Shader shader, int uniformLoc, Span<T> values, ShaderUniformDataType uniformType, int count)
+        public static void SetShaderValueV<T>(
-        where T : unmanaged
+            Shader shader,
+            int locIndex,
+            Span<T> values,
+            ShaderUniformDataType uniformType,
+            int count
+        ) where T : unmanaged
         {
             fixed (T* valuePtr = values)
             {
-                SetShaderValueV(shader, uniformLoc, valuePtr, uniformType, count);
+                SetShaderValueV(shader, locIndex, valuePtr, uniformType, count);
             }
         }
 
         /// <summary>Set shader uniform value</summary>
-        public static void SetShaderValue<T>(Shader shader, int uniformLoc, T value, ShaderUniformDataType uniformType)
+        public static void SetShaderValue<T>(Shader shader, int locIndex, T value, ShaderUniformDataType uniformType)
         where T : unmanaged
         {
-            SetShaderValue(shader, uniformLoc, &value, uniformType);
+            SetShaderValue(shader, locIndex, &value, uniformType);
         }
 
         /// <summary>Set shader uniform value</summary>
-        public static void SetShaderValue<T>(Shader shader, int uniformLoc, T[] values, ShaderUniformDataType uniformType)
+        public static void SetShaderValue<T>(
-        where T : unmanaged
+            Shader shader,
+            int locIndex,
+            T[] values,
+            ShaderUniformDataType uniformType
+        ) where T : unmanaged
         {
-            SetShaderValue(shader, uniformLoc, (Span<T>)values, uniformType);
+            SetShaderValue(shader, locIndex, (Span<T>)values, uniformType);
         }
 
         /// <summary>Set shader uniform value</summary>
-        public static void SetShaderValue<T>(Shader shader, int uniformLoc, Span<T> values, ShaderUniformDataType uniformType)
+        public static void SetShaderValue<T>(
-        where T : unmanaged
+            Shader shader,
+            int locIndex,
+            Span<T> values,
+            ShaderUniformDataType uniformType
+        ) where T : unmanaged
         {
             fixed (T* valuePtr = values)
             {
-                SetShaderValue(shader, uniformLoc, valuePtr, uniformType);
+                SetShaderValue(shader, locIndex, valuePtr, uniformType);
             }
         }
 
@@ -209,16 +227,24 @@ namespace Raylib_cs
         }
 
         /// <summary>Update camera position for selected mode</summary>
-        public static void UpdateCamera(ref Camera3D camera)
+        public static void UpdateCamera(ref Camera3D camera, CameraMode mode)
         {
             fixed (Camera3D* c = &camera)
             {
-                UpdateCamera(c);
+                UpdateCamera(c, mode);
             }
         }
 
-        /// <summary>Check the collision between two lines defined by two points each, returns collision point by reference</summary>
+        /// <summary>
-        public static CBool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, ref Vector2 collisionPoint)
+        /// Check the collision between two lines defined by two points each, returns collision point by reference
+        /// </summary>
+        public static CBool CheckCollisionLines(
+            Vector2 startPos1,
+            Vector2 endPos1,
+            Vector2 startPos2,
+            Vector2 endPos2,
+            ref Vector2 collisionPoint
+        )
         {
             fixed (Vector2* p = &collisionPoint)
             {
@@ -322,7 +348,14 @@ namespace Raylib_cs
         }
 
         /// <summary>Resize canvas and fill with color</summary>
-        public static void ImageResizeCanvas(ref Image image, int newWidth, int newHeight, int offsetX, int offsetY, Color color)
+        public static void ImageResizeCanvas(
+            ref Image image,
+            int newWidth,
+            int newHeight,
+            int offsetX,
+            int offsetY,
+            Color color
+        )
         {
             fixed (Image* p = &image)
             {
@@ -466,7 +499,14 @@ namespace Raylib_cs
         }
 
         /// <summary>Draw line within an image</summary>
-        public static void ImageDrawLine(ref Image dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color)
+        public static void ImageDrawLine(
+            ref Image dst,
+            int startPosX,
+            int startPosY,
+            int endPosX,
+            int endPosY,
+            Color color
+        )
         {
             fixed (Image* p = &dst)
             {
@@ -557,7 +597,15 @@ namespace Raylib_cs
         }
 
         /// <summary>Draw text (custom sprite font) within an image (destination)</summary>
-        public static void ImageDrawTextEx(ref Image dst, Font font, string text, Vector2 position, int fontSize, float spacing, Color color)
+        public static void ImageDrawTextEx(
+            ref Image dst,
+            Font font,
+            string text,
+            Vector2 position,
+            int fontSize,
+            float spacing,
+            Color color
+        )
         {
             using var str1 = text.ToUTF8Buffer();
             fixed (Image* p = &dst)
@@ -636,19 +684,19 @@ namespace Raylib_cs
         }
 
         /// <summary>Load model animations from file</summary>
-        public static ReadOnlySpan<ModelAnimation> LoadModelAnimations(string fileName, ref uint animsCount)
+        public static ReadOnlySpan<ModelAnimation> LoadModelAnimations(string fileName, ref uint animCount)
         {
             using var str1 = fileName.ToUTF8Buffer();
-            fixed (uint* p = &animsCount)
+            fixed (uint* p = &animCount)
             {
-                var model = LoadModelAnimations(str1.AsPointer(), p);
+                ModelAnimation* modelAnimations = LoadModelAnimations(str1.AsPointer(), p);
 
-                if ((IntPtr)model == IntPtr.Zero)
+                if ((IntPtr)modelAnimations == IntPtr.Zero)
                 {
                     throw new ApplicationException("Failed to load animation");
                 }
 
-                return new ReadOnlySpan<ModelAnimation>(model, (int)animsCount);
+                return new ReadOnlySpan<ModelAnimation>(modelAnimations, (int)animCount);
             }
         }
 
@@ -680,41 +728,29 @@ namespace Raylib_cs
         }
 
         /// <summary>Draw lines sequence</summary>
-        public static void DrawLineStrip(Vector2[] points, int numPoints, Color color)
+        public static void DrawLineStrip(Vector2[] points, int pointCount, Color color)
         {
             fixed (Vector2* p = points)
             {
-                DrawLineStrip(p, numPoints, color);
+                DrawLineStrip(p, pointCount, color);
             }
         }
 
         /// <summary>Draw a triangle fan defined by points (first vertex is the center)</summary>
-        public static void DrawTriangleFan(Vector2[] points, int numPoints, Color color)
+        public static void DrawTriangleFan(Vector2[] points, int pointCount, Color color)
         {
             fixed (Vector2* p = points)
             {
-                DrawTriangleFan(p, numPoints, color);
+                DrawTriangleFan(p, pointCount, color);
             }
         }
 
         /// <summary>Draw a triangle strip defined by points</summary>
-        public static void DrawTriangleStrip(Vector2[] points, int pointsCount, Color color)
+        public static void DrawTriangleStrip(Vector2[] points, int pointCount, Color color)
         {
             fixed (Vector2* p = points)
             {
-                DrawTriangleStrip(p, pointsCount, color);
+                DrawTriangleStrip(p, pointCount, color);
-            }
-        }
-
-        /// <summary>Draw a textured polygon</summary>
-        public static void DrawTexturePoly(Texture2D texture, Vector2 center, Vector2[] points, Vector2[] texcoords, int pointsCount, Color tint)
-        {
-            fixed (Vector2* p = points)
-            {
-                fixed (Vector2* p1 = texcoords)
-                {
-                    DrawTexturePoly(texture, center, p, p1, pointsCount, tint);
-                }
             }
         }
 
@@ -726,14 +762,30 @@ namespace Raylib_cs
         }
 
         /// <summary>Draw text using font and additional parameters</summary>
-        public static void DrawTextEx(Font font, string text, Vector2 position, float fontSize, float spacing, Color tint)
+        public static void DrawTextEx(
+            Font font,
+            string text,
+            Vector2 position,
+            float fontSize,
+            float spacing,
+            Color tint
+        )
         {
             using var str1 = text.ToUTF8Buffer();
             DrawTextEx(font, str1.AsPointer(), position, fontSize, spacing, tint);
         }
 
         /// <summary>Draw text using Font and pro parameters (rotation)</summary>
-        public static void DrawTextPro(Font font, string text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint)
+        public static void DrawTextPro(
+            Font font,
+            string text,
+            Vector2 position,
+            Vector2 origin,
+            float rotation,
+            float fontSize,
+            float spacing,
+            Color tint
+        )
         {
             using var str1 = text.ToUTF8Buffer();
             DrawTextPro(font, str1.AsPointer(), position, origin, rotation, fontSize, spacing, tint);
@@ -788,40 +840,40 @@ namespace Raylib_cs
             }
         }
 
-        /// <summary>Get total number of characters (codepoints) in a UTF8 encoded string</summary>
+        /// <summary>Get total number of codepoints in a UTF8 encoded string</summary>
         public static int GetCodepointCount(string text)
         {
             using var str1 = text.ToUTF8Buffer();
             return GetCodepointCount(str1.AsPointer());
         }
 
-        /// <summary>Get next codepoint in a UTF8 encoded string; 0x3f('?') is returned on failure</summary>
+        /// <summary>Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure</summary>
         /// <returns>single codepoint / "char"</returns>
-        public static int GetCodepoint(string text, ref int bytesProcessed)
+        public static int GetCodepoint(string text, ref int codepointSize)
         {
             using var str1 = text.ToUTF8Buffer();
-            fixed (int* p = &bytesProcessed)
+            fixed (int* p = &codepointSize)
             {
-                return GetCodepoint(str1.AsPointer(), p);
+                return GetCodepointNext(str1.AsPointer(), p);
             }
         }
 
-        /// <summary>Encode codepoint into utf8 text (char array length returned as parameter)</summary>
+        /// <summary>Encode one codepoint into UTF-8 byte array (array length returned as parameter)</summary>
-        public static string CodepointToUTF8(int codepoint, ref int byteSize)
+        public static string CodepointToUTF8(int codepoint, ref int utf8Size)
         {
-            fixed (int* l1 = &byteSize)
+            fixed (int* l1 = &utf8Size)
             {
                 var ptr = CodepointToUTF8(codepoint, l1);
                 return Utf8StringUtils.GetUTF8String(ptr);
             }
         }
 
-        /// <summary>Encode codepoint into utf8 text (char array length returned as parameter)</summary>
+        /// <summary>Load UTF-8 text encoded from codepoints array</summary>
-        public static string TextCodepointsToUTF8(int[] codepoints, int length)
+        public static string LoadUTF8(int[] codepoints, int length)
         {
             fixed (int* c1 = codepoints)
             {
-                var ptr = TextCodepointsToUTF8(c1, length);
+                var ptr = LoadUTF8(c1, length);
                 var text = Utf8StringUtils.GetUTF8String(ptr);
                 MemFree(ptr);
                 return text;
@@ -843,11 +895,11 @@ namespace Raylib_cs
         }
 
         /// <summary>Draw a triangle strip defined by points</summary>
-        public static void DrawTriangleStrip3D(Vector3[] points, int pointsCount, Color color)
+        public static void DrawTriangleStrip3D(Vector3[] points, int pointCount, Color color)
         {
             fixed (Vector3* p = points)
             {
-                DrawTriangleStrip3D(p, pointsCount, color);
+                DrawTriangleStrip3D(p, pointCount, color);
             }
         }
 
@@ -910,7 +962,12 @@ namespace Raylib_cs
             return model.materials[materialIndex].maps[(int)mapIndex].texture;
         }
 
-        public static void SetMaterialTexture(ref Model model, int materialIndex, MaterialMapIndex mapIndex, ref Texture2D texture)
+        public static void SetMaterialTexture(
+            ref Model model,
+            int materialIndex,
+            MaterialMapIndex mapIndex,
+            ref Texture2D texture
+        )
         {
             SetMaterialTexture(&model.materials[materialIndex], mapIndex, texture);
         }

Raylib-cs/types/Texture2D.cs

@@ -82,7 +82,7 @@ namespace Raylib_cs
         CUBEMAP_LAYOUT_LINE_VERTICAL,
 
         /// <summary>
-        /// Layout is defined by an horizontal line with faces
+        /// Layout is defined by a horizontal line with faces
         /// </summary>
         CUBEMAP_LAYOUT_LINE_HORIZONTAL,