Changing Dllimport calling conventions to Cdecl

Bindings/Easings.cs

@@ -15,96 +15,96 @@ namespace Raylib
         #region Raylib-cs Functions
                 
         // Linear Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseLinearNone(float t, float b, float c, float d);
        
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseLinearIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseLinearOut(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseLinearInOut(float t, float b, float c, float d);
         
         // Sine Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseSineIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseSineOut(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseSineInOut(float t, float b, float c, float d);
         
         // Circular Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseCircIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseCircOut(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseCircInOut(float t, float b, float c, float d);
         
         // Cubic Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseCubicIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseCubicOut(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseCubicInOut(float t, float b, float c, float d);
         
         // Quadratic Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseQuadIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseQuadOut(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseQuadInOut(float t, float b, float c, float d);
        
         // Exponential Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseExpoIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseExpoOut(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseExpoInOut(float t, float b, float c, float d);
         
         // Back Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseBackIn(float t, float b, float c, float d);
      
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseBackOut(float t, float b, float c, float d);
    
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseBackInOut(float t, float b, float c, float d);
      
         // Bounce Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseBounceOut(float t, float b, float c, float d);
 
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseBounceIn(float t, float b, float c, float d);
         
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseBounceInOut(float t, float b, float c, float d); 
      
         // Elastic Easing functions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseElasticIn(float t, float b, float c, float d);
        
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseElasticOut(float t, float b, float c, float d);
 
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float EaseElasticInOut(float t, float b, float c, float d);
 
         #endregion

Bindings/Physac.cs

@@ -123,15 +123,15 @@ namespace Raylib
         #region Raylib-cs Functions 
 
         // Initializes physics values, pointers and creates physics loop thread
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void InitPhysics();                                                                          
 
         // Returns true if physics thread is currently enabled
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool IsPhysicsEnabled();                                                                      
 
         // Sets physics global gravity force
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void SetPhysicsGravity(float x, float y);                                                         
 
         // Creates a new circle physics body with generic parameters
@@ -166,19 +166,19 @@ namespace Raylib
         }
 
         // Adds a force to a physics body
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void PhysicsAddForce(PhysicsBodyData body, Vector2 force);                                            
 
         // Adds an angular force to a physics body
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void PhysicsAddTorque(PhysicsBodyData body, float amount);                                            
         
         // Shatters a polygon shape physics body to little physics bodies with explosion force
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void PhysicsShatter(PhysicsBodyData body, Vector2 position, float force);                             
 
         // Returns the current amount of created physics bodies
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GetPhysicsBodiesCount();                                                                  
 
         // Returns a physics body of the bodies pool at a specific index
@@ -192,31 +192,31 @@ namespace Raylib
         }
 
         // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GetPhysicsShapeType(int index);                                                             
 
         // Returns the amount of vertices of a physics body shape
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GetPhysicsShapeVerticesCount(int index);                                                      
 
         // Returns transformed position of a body shape (body position + vertex transformed position)
-        [DllImport(nativeLibName)]
+        [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)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void SetPhysicsBodyRotation(PhysicsBodyData body, float radians);                                     
 
         // Unitializes and destroy a physics body
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void DestroyPhysicsBody(PhysicsBodyData body);                                                        
 
         // Destroys created physics bodies and manifolds and resets global values
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void ResetPhysics();                                                                        
 
         // Unitializes physics pointers and closes physics loop thread
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void ClosePhysics();                                                                      
 
         #endregion

Bindings/Raygui.cs

@@ -209,151 +209,151 @@ namespace Raylib
 
         // Global gui modification functions
         // Enable gui controls (global state)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiEnable();                                         
         
         // Disable gui controls (global state)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiDisable();                                        
         
         // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiFade(float alpha);                                    
           
         // Style set/get functions
         // Set one style property
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiSetStyleProperty(int guiProperty, int value);         
         
         // Get one style property
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiGetStyleProperty(int guiProperty);                     
              
         // Container/separator controls, useful for controls organization
         // Window Box control, shows a window that can be closed
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiWindowBox(Rectangle bounds, string text);                                        
         
         // Group Box control with title name
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiGroupBox(Rectangle bounds, string text);                                         
         
         // Line separator control
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiLine(Rectangle bounds, int thick);                                                    
         
         // Panel control, useful to group controls
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiPanel(Rectangle bounds);                                                              
         
         // Scroll Panel control
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 viewScroll);                   
         
         // Basic controls set
         // Label control, shows text
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiLabel(Rectangle bounds, string text);                                            
         
         // Button control, returns true when clicked
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiButton(Rectangle bounds, string text);                                           
         
         // Label button control, show true when clicked
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiLabelButton(Rectangle bounds, string text);                                      
         
         // Image button control, returns true when clicked
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiImageButton(Rectangle bounds, Texture2D texture);                                     
         
         // Image button extended control, returns true when clicked
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiImageButtonEx(Rectangle bounds, Texture2D texture, Rectangle texSource, string text); 
         
         // Toggle Button control, returns true when active
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiToggleButton(Rectangle bounds, string text, bool toggle);                        
         
         // Toggle Group control, returns toggled button index
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiToggleGroup(Rectangle bounds, string text, int count, int active);               
         
         // Check Box control, returns true when active
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiCheckBox(Rectangle bounds, bool isChecked);                                             
         
         // Check Box control with text, returns true when active
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiCheckBoxEx(Rectangle bounds, bool isChecked, string text);                         
         
         // Combo Box control, returns selected item index
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiComboBox(Rectangle bounds, string text, int count, int active);                  
         
         // Dropdown Box control, returns selected item
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiDropdownBox(Rectangle bounds, string[] text, int count, int active);               
         
         // Spinner control, returns selected value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiSpinner(Rectangle bounds, int value, int maxValue, int btnWidth);                      
         
         // Value Box control, updates input text with numbers
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiValueBox(Rectangle bounds, int value, int maxValue);                                   
         
         // Text Box control, updates input text
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiTextBox(Rectangle bounds, char text, int textSize, bool freeEdit);                   
         
         // Text Box control with multiple lines
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiTextBoxMulti(Rectangle bounds, string text, int textSize, bool editMode);          
         
         // Slider control, returns selected value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float GuiSlider(Rectangle bounds, float value, float minValue, float maxValue);               
         
         // Slider control, returns selected value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float GuiSliderEx(Rectangle bounds, float value, float minValue, float maxValue, string text, bool showValue); 
         
         // Slider Bar control, returns selected value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float GuiSliderBar(Rectangle bounds, float value, float minValue, float maxValue);            
         
         // Slider Bar control, returns selected value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float GuiSliderBarEx(Rectangle bounds, float value, float minValue, float maxValue, string text, bool showValue); 
         
         // Progress Bar control, shows current progress value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float GuiProgressBar(Rectangle bounds, float value, float minValue, float maxValue);          
         
         // Progress Bar control, shows current progress value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float GuiProgressBarEx(Rectangle bounds, float value, float minValue, float maxValue, bool showValue); 
         
         // Status Bar control, shows info text
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiStatusBar(Rectangle bounds, string text, int offsetX);                           
         
         // Dummy control for placeholders
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void GuiDummyRec(Rectangle bounds, string text);                                              
         
         // Advance controls set
         // List View control, returns selected list element index
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern int GuiListView(Rectangle bounds, string text, int count, int active);                  
         
         // Color Picker control
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Color GuiColorPicker(Rectangle bounds, Color color);                                          
         
         // Message Box control, displays a message
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern bool GuiMessageBox(Rectangle bounds, string windowTitle, string message);           
 
         #endregion

Bindings/Raymath.cs

@@ -288,299 +288,299 @@ namespace Raylib
         #region Raylib-cs Functions 
 
         // Clamp float value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Clamp(float value, float min, float max);
 
         // Vector with components value 0.0f
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Zero();
 
         // Vector with components value 1.0f
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2One();
 
         // Add two vectors (v1 + v2)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Add(Vector2 v1, Vector2 v2);
 
         // Subtract two vectors (v1 - v2)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Subtract(Vector2 v1, Vector2 v2);
 
         // Calculate vector length
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector2Length(Vector2 v);
 
         // Calculate two vectors dot product
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector2DotProduct(Vector2 v1, Vector2 v2);
 
         // Calculate distance between two vectors
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector2Distance(Vector2 v1, Vector2 v2);
 
         // Calculate angle from two vectors in X-axis
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector2Angle(Vector2 v1, Vector2 v2);
 
         // Scale vector (multiply by value)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Scale(Vector2 v, float scale);
 
         // Negate vector
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Negate(Vector2 v);
 
         // Divide vector by a float value
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Divide(Vector2 v, float div);
 
         // Normalize provided vector
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector2 Vector2Normalize(Vector2 v);
 
         // Vector with components value 0.0f
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Zero();
 
         // Vector with components value 1.0f
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3One();
 
         // Add two vectors
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Add(Vector3 v1, Vector3 v2);
 
         // Substract two vectors
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Subtract(Vector3 v1, Vector3 v2);
 
         // Multiply vector by scalar
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Multiply(Vector3 v, float scalar);
 
         // Multiply vector by vector
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3MultiplyV(Vector3 v1, Vector3 v2);
 
         // Calculate two vectors cross product
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2);
 
         // Calculate one vector perpendicular vector
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Perpendicular(Vector3 v);
 
         // Calculate vector length
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
 		public static extern float Vector3Length(Vector3 v);
 
         // Calculate two vectors dot product
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector3DotProduct(Vector3 v1, Vector3 v2);
 
         // Calculate distance between two vectors
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float Vector3Distance(Vector3 v1, Vector3 v2);
 
         // Scale provided vector
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Scale(Vector3 v, float scale);
 
         // Negate provided vector (invert direction)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Negate(Vector3 v);
 
         // Normalize provided vector
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Normalize(Vector3 v);
 
         // Orthonormalize provided vectors
         // Makes vectors normalized and orthogonal to each other
         // Gram-Schmidt function implementation
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void Vector3OrthoNormalize(out Vector3 v1, out Vector3 v2);
 
         // Transforms a Vector3 by a given Matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Transform(Vector3 v, Matrix mat);
 
         // Transform a vector by quaternion rotation
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q);
         
         // Calculate linear interpolation between two vectors
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount);
         
         // Calculate reflected vector to normal
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Reflect(Vector3 v, Vector3 normal);
         
         // Return min value for each pair of components
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Min(Vector3 v1, Vector3 v2);
         
         // Return max value for each pair of components
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Max(Vector3 v1, Vector3 v2);
         
         // Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
         // NOTE: Assumes P is on the plane of the triangle
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c);
         
         // Returns Vector3 as float array
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float[] Vector3ToFloatV(Vector3 v);
 
         // Compute matrix determinant
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float MatrixDeterminant(Matrix mat);
 
         // Returns the trace of the matrix (sum of the values along the diagonal)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float MatrixTrace(Matrix mat);
 
         // Transposes provided matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixTranspose(Matrix mat);
 
         // Invert provided matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixInvert(Matrix mat);
         
         // Normalize provided matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixNormalize(Matrix mat);
         
         // Returns identity matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixIdentity();
 
         // Add two matrices
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixAdd(Matrix left, Matrix right);
         
         // Substract two matrices (left - right)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixSubstract(Matrix left, Matrix right);
         
         // Create rotation matrix from axis and angle
         // NOTE: Angle should be provided in radians
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixTranslate(float x, float y, float z);
        
         // Returns x-rotation matrix (angle in radians)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixRotate(Vector3 axis, float angle);
 
         // Returns x-rotation matrix (angle in radians)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixRotateX(float angle);
 
         // Returns y-rotation matrix (angle in radians)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixRotateY(float angle);
 
         // Returns z-rotation matrix (angle in radians)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixRotateZ(float angle);
 
         // Returns scaling matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixScale(float x, float y, float z);
         
         // Returns two matrix multiplication
         // NOTE: When multiplying matrices... the order matters!
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixMultiply(Matrix left, Matrix right);
         
         // Returns perspective projection matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far);
 
         // Returns perspective projection matrix
         // NOTE: Angle should be provided in radians
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixPerspective(double fovy, double aspect, double near, double far);
         
         // Returns orthographic projection matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far);
         
         // Returns camera look-at matrix (view matrix)
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up);
         
         // Returns float array of matrix data
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float[] MatrixToFloatV(Matrix mat);
             
         // Returns identity quaternion
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionIdentity();
         
         // Computes the length of a quaternion
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern float QuaternionLength(Quaternion q);
         
         // Normalize provided quaternion
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionNormalize(Quaternion q);
         
         // Invert provided quaternion
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionInvert(Quaternion q);
         
         // Calculate two quaternion multiplication
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);
         
         // Calculate linear interpolation between two quaternions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);
 
         // Calculate slerp-optimized interpolation between two quaternions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);
        
         // Calculates spherical linear interpolation between two quaternions
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);
         
         // Calculate quaternion based on the rotation from one vector to another
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);
         
         // Returns a quaternion for a given rotation matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionFromMatrix(Matrix mat);
        
         // Returns a matrix for a given quaternion
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Matrix QuaternionToMatrix(Quaternion q);
 
         // Returns rotation quaternion for an angle and axis
         // NOTE: angle must be provided in radians
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);
        
         // Returns the rotation angle and axis for a given quaternion
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern void QuaternionToAxisAngle(Quaternion q, out Vector3 outAxis, float[] outAngle);
         
         // Returns he quaternion equivalent to Euler angles
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionFromEuler(float roll, float pitch, float yaw);
 
         // Return the Euler angles equivalent to quaternion (roll, pitch, yaw)
         // NOTE: Angles are returned in a Vector3 struct in degrees
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Vector3 QuaternionToEuler(Quaternion q);
        
         // Transform a quaternion given a transformation matrix
-        [DllImport(nativeLibName)]
+        [DllImport(nativeLibName,CallingConvention = CallingConvention.Cdecl)]
         public static extern Quaternion QuaternionTransform(Quaternion q, Matrix mat);
 
 		#endregion