Alot of binding improvements!

- Improved bindings and added initial ones for Easings, Physac, Raygui and Raymath(Not yet fully tested).
- Renamed ExamplesApplication to Bindings to make it more clear.
- Examples separated from bindings.
- Improve readme to reflect changes.

Bindings/Easings.cs

@@ -0,0 +1,112 @@
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Raylib
+{
+    #region Raylib-cs Enums
+
+    #endregion
+
+    #region Raylib-cs Types
+
+
+    #endregion
+
+    public static partial class rl
+    {
+        #region Raylib-cs Variables
+
+		#endregion
+
+        #region Raylib-cs Functions
+                
+        // Linear Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseLinearNone(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseLinearIn(float t, float b, float c, float d);
+        
+        [DllImport(nativeLibName)]
+        public static extern float EaseLinearOut(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseLinearInOut(float t, float b, float c, float d);
+        
+        // Sine Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseSineIn(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseSineOut(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseSineInOut(float t, float b, float c, float d);
+        
+        // Circular Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseCircIn(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseCircOut(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseCircInOut(float t, float b, float c, float d);
+        
+        // Cubic Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseCubicIn(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseCubicOut(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseCubicInOut(float t, float b, float c, float d);
+        
+        // Quadratic Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseQuadIn(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseQuadOut(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseQuadInOut(float t, float b, float c, float d);
+
+        
+        // Exponential Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseExpoIn(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseExpoOut(float t, float b, float c, float d);
+        [DllImport(nativeLibName)]
+        public static extern float EaseExpoInOut(float t, float b, float c, float d);
+ 
+        
+        // Back Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseBackIn(float t, float b, float c, float d);
+     
+        [DllImport(nativeLibName)]
+        public static extern float EaseBackOut(float t, float b, float c, float d);
+   
+        [DllImport(nativeLibName)]
+        public static extern float EaseBackInOut(float t, float b, float c, float d);
+
+        
+        // Bounce Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseBounceOut(float t, float b, float c, float d);
+
+        [DllImport(nativeLibName)]
+        public static extern float EaseBounceIn(float t, float b, float c, float d);
+        
+        [DllImport(nativeLibName)]
+        public static extern float EaseBounceInOut(float t, float b, float c, float d); 
+
+        
+        // Elastic Easing functions
+        [DllImport(nativeLibName)]
+        public static extern float EaseElasticIn(float t, float b, float c, float d);
+       
+        [DllImport(nativeLibName)]
+        public static extern float EaseElasticOut(float t, float b, float c, float d);
+
+        [DllImport(nativeLibName)]
+        public static extern float EaseElasticInOut(float t, float b, float c, float d);
+
+        #endregion
+
+    }
+}

Bindings/Program.cs

@@ -0,0 +1,11 @@
+
+namespace Bindings
+{
+    static class Program
+    {
+        static void Main(string[] args)
+        {
+            Examples.core_basic_window();
+        }
+    }
+}

Bindings/Raygui.cs

@@ -0,0 +1,361 @@
+
+using System;
+using System.Runtime.InteropServices;
+
+namespace Raylib
+{
+    #region Raylib-cs Enums
+
+    // Gui properties enumeration
+    enum GuiProperty
+    {
+        //--------------------------------------------
+        // NOTE: This first set of properties is for general style,
+        // following control-specific properties overwritte those styles
+        DEFAULT_BACKGROUND_COLOR = 0,
+        DEFAULT_LINES_COLOR,
+        DEFAULT_TEXT_FONT,
+        DEFAULT_TEXT_SIZE,
+        DEFAULT_BORDER_WIDTH,
+        DEFAULT_BORDER_COLOR_NORMAL,
+        DEFAULT_BASE_COLOR_NORMAL,
+        DEFAULT_TEXT_COLOR_NORMAL,
+        DEFAULT_BORDER_COLOR_FOCUSED,
+        DEFAULT_BASE_COLOR_FOCUSED,
+        DEFAULT_TEXT_COLOR_FOCUSED,
+        DEFAULT_BORDER_COLOR_PRESSED,
+        DEFAULT_BASE_COLOR_PRESSED,
+        DEFAULT_TEXT_COLOR_PRESSED,
+        DEFAULT_BORDER_COLOR_DISABLED,
+        DEFAULT_BASE_COLOR_DISABLED,
+        DEFAULT_TEXT_COLOR_DISABLED,
+        //--------------------------------------------
+        // Label
+        LABEL_TEXT_COLOR_NORMAL,
+        LABEL_TEXT_COLOR_FOCUSED,
+        LABEL_TEXT_COLOR_PRESSED,
+        LABEL_TEXT_COLOR_DISABLED,
+        // Button
+        BUTTON_BORDER_WIDTH,
+        BUTTON_BORDER_COLOR_NORMAL,
+        BUTTON_BASE_COLOR_NORMAL,
+        BUTTON_TEXT_COLOR_NORMAL,
+        BUTTON_BORDER_COLOR_FOCUSED,
+        BUTTON_BASE_COLOR_FOCUSED,
+        BUTTON_TEXT_COLOR_FOCUSED,
+        BUTTON_BORDER_COLOR_PRESSED,
+        BUTTON_BASE_COLOR_PRESSED,
+        BUTTON_TEXT_COLOR_PRESSED,
+        BUTTON_BORDER_COLOR_DISABLED,
+        BUTTON_BASE_COLOR_DISABLED,
+        BUTTON_TEXT_COLOR_DISABLED,
+        // Toggle
+        TOGGLE_BORDER_WIDTH,
+        TOGGLE_BORDER_COLOR_NORMAL,
+        TOGGLE_BASE_COLOR_NORMAL,
+        TOGGLE_TEXT_COLOR_NORMAL,
+        TOGGLE_BORDER_COLOR_FOCUSED,
+        TOGGLE_BASE_COLOR_FOCUSED,
+        TOGGLE_TEXT_COLOR_FOCUSED,
+        TOGGLE_BORDER_COLOR_PRESSED,
+        TOGGLE_BASE_COLOR_PRESSED,
+        TOGGLE_TEXT_COLOR_PRESSED,
+        TOGGLE_BORDER_COLOR_DISABLED,
+        TOGGLE_BASE_COLOR_DISABLED,
+        TOGGLE_TEXT_COLOR_DISABLED,
+        TOGGLEGROUP_PADDING,
+        // Slider
+        SLIDER_BORDER_WIDTH,
+        SLIDER_SLIDER_WIDTH,
+        SLIDER_BORDER_COLOR_NORMAL,
+        SLIDER_BASE_COLOR_NORMAL,
+        SLIDER_BORDER_COLOR_FOCUSED,
+        SLIDER_BASE_COLOR_FOCUSED,
+        SLIDER_BORDER_COLOR_PRESSED,
+        SLIDER_BASE_COLOR_PRESSED,
+        SLIDER_BORDER_COLOR_DISABLED,
+        SLIDER_BASE_COLOR_DISABLED,
+        // SliderBar
+        SLIDERBAR_INNER_PADDING,
+        SLIDERBAR_BORDER_WIDTH,
+        SLIDERBAR_BORDER_COLOR_NORMAL,
+        SLIDERBAR_BASE_COLOR_NORMAL,
+        SLIDERBAR_BORDER_COLOR_FOCUSED,
+        SLIDERBAR_BASE_COLOR_FOCUSED,
+        SLIDERBAR_BORDER_COLOR_PRESSED,
+        SLIDERBAR_BASE_COLOR_PRESSED,
+        SLIDERBAR_BORDER_COLOR_DISABLED,
+        SLIDERBAR_BASE_COLOR_DISABLED,
+        // ProgressBar
+        PROGRESSBAR_INNER_PADDING,
+        PROGRESSBAR_BORDER_WIDTH,
+        PROGRESSBAR_BORDER_COLOR_NORMAL,
+        PROGRESSBAR_BASE_COLOR_NORMAL,
+        PROGRESSBAR_BORDER_COLOR_FOCUSED,
+        PROGRESSBAR_BASE_COLOR_FOCUSED,
+        PROGRESSBAR_BORDER_COLOR_PRESSED,
+        PROGRESSBAR_BASE_COLOR_PRESSED,
+        PROGRESSBAR_BORDER_COLOR_DISABLED,
+        PROGRESSBAR_BASE_COLOR_DISABLED,
+        // ValueBox
+        VALUEBOX_BUTTON_PADDING,
+        VALUEBOX_BUTTONS_WIDTH,
+        VALUEBOX_BORDER_COLOR_NORMAL,
+        VALUEBOX_BASE_COLOR_NORMAL,
+        VALUEBOX_TEXT_COLOR_NORMAL,
+        VALUEBOX_BORDER_COLOR_FOCUSED,
+        VALUEBOX_BASE_COLOR_FOCUSED,
+        VALUEBOX_TEXT_COLOR_FOCUSED,
+        VALUEBOX_BORDER_COLOR_PRESSED,
+        VALUEBOX_BASE_COLOR_PRESSED,
+        VALUEBOX_TEXT_COLOR_PRESSED,
+        VALUEBOX_BORDER_COLOR_DISABLED,
+        VALUEBOX_BASE_COLOR_DISABLED,
+        VALUEBOX_TEXT_COLOR_DISABLED,
+        // ComboBox
+        COMBOBOX_BORDER_WIDTH,
+        COMBOBOX_BUTTON_PADDING,
+        COMBOBOX_SELECTOR_WIDTH,
+        COMBOBOX_BORDER_COLOR_NORMAL,
+        COMBOBOX_BASE_COLOR_NORMAL,
+        COMBOBOX_TEXT_COLOR_NORMAL,
+        COMBOBOX_BORDER_COLOR_FOCUSED,
+        COMBOBOX_BASE_COLOR_FOCUSED,
+        COMBOBOX_TEXT_COLOR_FOCUSED,
+        COMBOBOX_BORDER_COLOR_PRESSED,
+        COMBOBOX_BASE_COLOR_PRESSED,
+        COMBOBOX_TEXT_COLOR_PRESSED,
+        COMBOBOX_BORDER_COLOR_DISABLED,
+        COMBOBOX_BASE_COLOR_DISABLED,
+        COMBOBOX_TEXT_COLOR_DISABLED,
+        // CheckBox
+        CHECKBOX_BORDER_WIDTH,
+        CHECKBOX_INNER_PADDING,
+        CHECKBOX_BORDER_COLOR_NORMAL,
+        CHECKBOX_BASE_COLOR_NORMAL,
+        CHECKBOX_BORDER_COLOR_FOCUSED,
+        CHECKBOX_BASE_COLOR_FOCUSED,
+        CHECKBOX_BORDER_COLOR_PRESSED,
+        CHECKBOX_BASE_COLOR_PRESSED,
+        CHECKBOX_BORDER_COLOR_DISABLED,
+        CHECKBOX_BASE_COLOR_DISABLED,
+        // TextBox
+        TEXTBOX_BORDER_WIDTH,
+        TEXTBOX_BORDER_COLOR_NORMAL,
+        TEXTBOX_BASE_COLOR_NORMAL,
+        TEXTBOX_TEXT_COLOR_NORMAL,
+        TEXTBOX_BORDER_COLOR_FOCUSED,
+        TEXTBOX_BASE_COLOR_FOCUSED,
+        TEXTBOX_TEXT_COLOR_FOCUSED,
+        TEXTBOX_BORDER_COLOR_PRESSED,
+        TEXTBOX_BASE_COLOR_PRESSED,
+        TEXTBOX_TEXT_COLOR_PRESSED,
+        TEXTBOX_BORDER_COLOR_DISABLED,
+        TEXTBOX_BASE_COLOR_DISABLED,
+        TEXTBOX_TEXT_COLOR_DISABLED,
+        // ColorPicker
+        COLORPICKER_BARS_THICK,
+        COLORPICKER_BARS_PADDING,
+        COLORPICKER_BORDER_COLOR_NORMAL,
+        COLORPICKER_BASE_COLOR_NORMAL,
+        COLORPICKER_BORDER_COLOR_FOCUSED,
+        COLORPICKER_BASE_COLOR_FOCUSED,
+        COLORPICKER_BORDER_COLOR_PRESSED,
+        COLORPICKER_BASE_COLOR_PRESSED,
+        COLORPICKER_BORDER_COLOR_DISABLED,
+        COLORPICKER_BASE_COLOR_DISABLED,
+        // ListView
+        LISTVIEW_ELEMENTS_HEIGHT,
+        LISTVIEW_ELEMENTS_PADDING,
+        LISTVIEW_BAR_WIDTH,
+        LISTVIEW_BORDER_COLOR_NORMAL,
+        LISTVIEW_BASE_COLOR_NORMAL,
+        LISTVIEW_TEXT_COLOR_NORMAL,
+        LISTVIEW_BORDER_COLOR_FOCUSED,
+        LISTVIEW_BASE_COLOR_FOCUSED,
+        LISTVIEW_TEXT_COLOR_FOCUSED,
+        LISTVIEW_BORDER_COLOR_PRESSED,
+        LISTVIEW_BASE_COLOR_PRESSED,
+        LISTVIEW_TEXT_COLOR_PRESSED,
+        LISTVIEW_BORDER_COLOR_DISABLED,
+        LISTVIEW_BASE_COLOR_DISABLED,
+        LISTVIEW_TEXT_COLOR_DISABLED
+    }
+
+    #endregion
+
+    #region Raylib-cs Types
+
+
+    #endregion
+
+    public static partial class rl
+    {
+        #region Raylib-cs Variables
+
+		#endregion
+
+        #region Raylib-cs Functions
+
+        //----------------------------------------------------------------------------------
+        // Module Functions Declaration
+        //----------------------------------------------------------------------------------
+        
+        // Global gui modification functions
+        // Enable gui controls (global state)
+        [DllImport(nativeLibName)]
+        public static extern void GuiEnable();                                         
+        
+        // Disable gui controls (global state)
+        [DllImport(nativeLibName)]
+        public static extern void GuiDisable();                                        
+        
+        // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
+        [DllImport(nativeLibName)]
+        public static extern void GuiFade(float alpha);                                    
+        
+        
+        // Style set/get functions
+        // Set one style property
+        [DllImport(nativeLibName)]
+        public static extern void GuiSetStyleProperty(int guiProperty, int value);         
+        
+        // Get one style property
+        [DllImport(nativeLibName)]
+        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)]
+        public static extern bool GuiWindowBox(Rectangle bounds, string text);                                        
+        
+        // Group Box control with title name
+        [DllImport(nativeLibName)]
+        public static extern void GuiGroupBox(Rectangle bounds, string text);                                         
+        
+        // Line separator control
+        [DllImport(nativeLibName)]
+        public static extern void GuiLine(Rectangle bounds, int thick);                                                    
+        
+        // Panel control, useful to group controls
+        [DllImport(nativeLibName)]
+        public static extern void GuiPanel(Rectangle bounds);                                                              
+        
+        // Scroll Panel control
+        [DllImport(nativeLibName)]
+        public static extern Vector2 GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 viewScroll);              
+        
+        
+        
+        // Basic controls set
+        // Label control, shows text
+        [DllImport(nativeLibName)]
+        public static extern void GuiLabel(Rectangle bounds, string text);                                            
+        
+        // Button control, returns true when clicked
+        [DllImport(nativeLibName)]
+        public static extern bool GuiButton(Rectangle bounds, string text);                                           
+        
+        // Label button control, show true when clicked
+        [DllImport(nativeLibName)]
+        public static extern bool GuiLabelButton(Rectangle bounds, string text);                                      
+        
+        // Image button control, returns true when clicked
+        [DllImport(nativeLibName)]
+        public static extern bool GuiImageButton(Rectangle bounds, Texture2D texture);                                     
+        
+        // Image button extended control, returns true when clicked
+        [DllImport(nativeLibName)]
+        public static extern bool GuiImageButtonEx(Rectangle bounds, Texture2D texture, Rectangle texSource, string text); 
+        
+        // Toggle Button control, returns true when active
+        [DllImport(nativeLibName)]
+        public static extern bool GuiToggleButton(Rectangle bounds, string text, bool toggle);                        
+        
+        // Toggle Group control, returns toggled button index
+        [DllImport(nativeLibName)]
+        public static extern int GuiToggleGroup(Rectangle bounds, string text, int count, int active);               
+        
+        // Check Box control, returns true when active
+        [DllImport(nativeLibName)]
+        public static extern bool GuiCheckBox(Rectangle bounds, bool isChecked);                                             
+        
+        // Check Box control with text, returns true when active
+        [DllImport(nativeLibName)]
+        public static extern bool GuiCheckBoxEx(Rectangle bounds, bool isChecked, string text);                         
+        
+        // Combo Box control, returns selected item index
+        [DllImport(nativeLibName)]
+        public static extern int GuiComboBox(Rectangle bounds, string text, int count, int active);                  
+        
+        // Dropdown Box control, returns selected item
+        [DllImport(nativeLibName)]
+        public static extern int GuiDropdownBox(Rectangle bounds, string[] text, int count, int active);               
+        
+        // Spinner control, returns selected value
+        [DllImport(nativeLibName)]
+        public static extern int GuiSpinner(Rectangle bounds, int value, int maxValue, int btnWidth);                      
+        
+        // Value Box control, updates input text with numbers
+        [DllImport(nativeLibName)]
+        public static extern int GuiValueBox(Rectangle bounds, int value, int maxValue);                                   
+        
+        // Text Box control, updates input text
+        [DllImport(nativeLibName)]
+        public static extern bool GuiTextBox(Rectangle bounds, char text, int textSize, bool freeEdit);                   
+        
+        // Text Box control with multiple lines
+        [DllImport(nativeLibName)]
+        public static extern bool GuiTextBoxMulti(Rectangle bounds, string text, int textSize, bool editMode);          
+        
+        // Slider control, returns selected value
+        [DllImport(nativeLibName)]
+        public static extern float GuiSlider(Rectangle bounds, float value, float minValue, float maxValue);               
+        
+        // Slider control, returns selected value
+        [DllImport(nativeLibName)]
+        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)]
+        public static extern float GuiSliderBar(Rectangle bounds, float value, float minValue, float maxValue);            
+        
+        // Slider Bar control, returns selected value
+        [DllImport(nativeLibName)]
+        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)]
+        public static extern float GuiProgressBar(Rectangle bounds, float value, float minValue, float maxValue);          
+        
+        // Progress Bar control, shows current progress value
+        [DllImport(nativeLibName)]
+        public static extern float GuiProgressBarEx(Rectangle bounds, float value, float minValue, float maxValue, bool showValue); 
+        
+        // Status Bar control, shows info text
+        [DllImport(nativeLibName)]
+        public static extern void GuiStatusBar(Rectangle bounds, string text, int offsetX);                           
+        
+        // Dummy control for placeholders
+        [DllImport(nativeLibName)]
+        public static extern void GuiDummyRec(Rectangle bounds, string text);                                         
+        
+        
+        // Advance controls set
+        // List View control, returns selected list element index
+        [DllImport(nativeLibName)]
+        public static extern int GuiListView(Rectangle bounds, string text, int count, int active);                  
+        
+        // Color Picker control
+        [DllImport(nativeLibName)]
+        public static extern Color GuiColorPicker(Rectangle bounds, Color color);                                          
+        
+        // Message Box control, displays a message
+        [DllImport(nativeLibName)]
+        public static extern bool GuiMessageBox(Rectangle bounds, string windowTitle, string message);           
+
+        #endregion
+        
+    }
+}

Bindings/Raylib.cs

@@ -407,7 +407,7 @@ namespace Raylib
         public int offsetX; // Character offset X when drawing
         public int offsetY; // Character offset Y when drawing
         public int advanceX; // Character advance position X
-        public byte[] data; // Character pixel data (grayscale)
+	    public unsafe void* data;// Character pixel data (grayscale)
     }
 
     // Font type, includes texture and charSet array data
@@ -417,7 +417,7 @@ namespace Raylib
         public Texture2D texture; // Font texture
         public int baseSize; // Base size (default chars height)
         public int charsCount; // Number of characters
-        public CharInfo[] chars; // Characters info data
+	    public unsafe CharInfo* chars; // Characters info data
     }
 
     // Camera type, defines a camera position/orientation in 3d space

Bindings/Raymath.cs

@@ -27,6 +27,11 @@ namespace Raylib
             return x.GetHashCode() + y.GetHashCode();
         }
 
+        public override string ToString()
+        {
+            return "Vector2(" + x + " " + y + ")";
+        }
+        
         // utility for c functions Vector2Zero -> Zero etc
         [DllImport(rl.nativeLibName, EntryPoint = "Vector2Zero")]
         public static extern Vector2 Zero();
@@ -137,9 +142,12 @@ namespace Raylib
         public static extern Vector3 Normalize(Vector3 v);
 
         // operators
-        [DllImport(rl.nativeLibName, EntryPoint = "Vector3Scale")]
+        [DllImport(rl.nativeLibName, EntryPoint = "Vector3MultiplyV")]
         public static extern Vector3 operator *(Vector3 v1, Vector3 v3);
 
+        [DllImport(rl.nativeLibName, EntryPoint = "Vector3Multiply")]
+        public static extern Vector3 operator *(Vector3 v1, float scale);
+        
         [DllImport(rl.nativeLibName, EntryPoint = "Vector3Divide")]
         public static extern Vector3 operator /(Vector3 v1, Vector3 v3);
 
@@ -348,111 +356,154 @@ namespace Raylib
         [DllImport(nativeLibName)]
         public static extern float[] Vector3ToFloatV(Vector3 v);
 
+
+        // Compute matrix determinant
         [DllImport(nativeLibName)]
         public static extern float MatrixDeterminant(Matrix mat);
 
+        // Returns the trace of the matrix (sum of the values along the diagonal)
         [DllImport(nativeLibName)]
         public static extern float MatrixTrace(Matrix mat);
 
+        // Transposes provided matrix
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixTranspose(Matrix mat);
 
+        // Invert provided matrix
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixInvert(Matrix mat);
-
+        
+        // Normalize provided matrix
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixNormalize(Matrix mat);
-
+        
+        // Returns identity matrix
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixIdentity();
 
+        // Add two matrices
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixAdd(Matrix left, Matrix right);
-
+        
+        // Substract two matrices (left - right)
         [DllImport(nativeLibName)]
         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)]
         public static extern Matrix MatrixTranslate(float x, float y, float z);
-
+       
+        // Returns x-rotation matrix (angle in radians)
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixRotate(Vector3 axis, float angle);
 
+        // Returns x-rotation matrix (angle in radians)
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixRotateX(float angle);
 
+        // Returns y-rotation matrix (angle in radians)
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixRotateY(float angle);
 
+        // Returns z-rotation matrix (angle in radians)
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixRotateZ(float angle);
 
+        // Returns scaling matrix
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixScale(float x, float y, float z);
-
+        
+        // Returns two matrix multiplication
+        // NOTE: When multiplying matrices... the order matters!
         [DllImport(nativeLibName)]
         public static extern Matrix MatrixMultiply(Matrix left, Matrix right);
-
+        
+        // Returns perspective projection matrix
         [DllImport(nativeLibName)]
         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)]
         public static extern Matrix MatrixPerspective(double fovy, double aspect, double near, double far);
-
+        
+        // Returns orthographic projection matrix
         [DllImport(nativeLibName)]
         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)]
         public static extern Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up);
-
+        
+        // Returns float array of matrix data
         [DllImport(nativeLibName)]
         public static extern float[] MatrixToFloatV(Matrix mat);
-
+       
+        
+        // Returns identity quaternion
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionIdentity();
-
+        
+        // Computes the length of a quaternion
         [DllImport(nativeLibName)]
         public static extern float QuaternionLength(Quaternion q);
-
+        
+        // Normalize provided quaternion
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionNormalize(Quaternion q);
-
+        
+        // Invert provided quaternion
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionInvert(Quaternion q);
-
+        
+        // Calculate two quaternion multiplication
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);
-
+        
+        // Calculate linear interpolation between two quaternions
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);
 
+        // Calculate slerp-optimized interpolation between two quaternions
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);
-
+       
+        // Calculates spherical linear interpolation between two quaternions
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);
-
+        
+        // Calculate quaternion based on the rotation from one vector to another
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);
-
+        
+        // Returns a quaternion for a given rotation matrix
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionFromMatrix(Matrix mat);
-
+       
+        // Returns a matrix for a given quaternion
         [DllImport(nativeLibName)]
         public static extern Matrix QuaternionToMatrix(Quaternion q);
 
+        // Returns rotation quaternion for an angle and axis
+        // NOTE: angle must be provided in radians
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);
-
+       
+        // Returns the rotation angle and axis for a given quaternion
         [DllImport(nativeLibName)]
         public static extern void QuaternionToAxisAngle(Quaternion q, out Vector3 outAxis, float[] outAngle);
-
+        
+        // Returns he quaternion equivalent to Euler angles
         [DllImport(nativeLibName)]
         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)]
         public static extern Vector3 QuaternionToEuler(Quaternion q);
-
+       
+        // Transform a quaternion given a transformation matrix
         [DllImport(nativeLibName)]
         public static extern Quaternion QuaternionTransform(Quaternion q, Matrix mat);
 

Bindings/core_basic_window.cs

@@ -0,0 +1 @@
+
using Raylib;
using static Raylib.rl;

public partial class Examples
{
    /*******************************************************************************************
    *
    *   raylib [core] example - Basic window
    *
    *   Welcome to raylib!
    *
    *   To test examples, just press F6 and execute raylib_compile_execute script
    *   Note that compiled executable is placed in the same folder as .c file
    *
    *   You can find all basic examples on C:\raylib\raylib\examples folder or
    *   raylib official webpage: www.raylib.com
    *
    *   Enjoy using raylib. :)
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    public static int core_basic_window()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Congrats! You created your first window!", 190, 200, 20, MAROON);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
}

ExampleApplication/Easings.cs

@@ -1,27 +0,0 @@
-
-using System;
-using System.Runtime.InteropServices;
-
-namespace Raylib
-{
-    #region Raylib-cs Enums
-
-    #endregion
-
-    #region Raylib-cs Types
-
-
-    #endregion
-
-    public static partial class rl
-    {
-        #region Raylib-cs Variables
-
-		#endregion
-
-        #region Raylib-cs Functions
-
-        #endregion
-        
-    }
-}

ExampleApplication/Examples/audio/audio_music_stream.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [audio] example - Music playing (streaming)
    *
    *   NOTE: This example requires OpenAL Soft library installed
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int audio_music_stream()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
    
        InitAudioDevice();              // Initialize audio device
    
        Music music = LoadMusicStream("resources/guitar_noodling.ogg");
        
        PlayMusicStream(music);
    
        float timePlayed = 0.0f;
        bool pause = false;
    
        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateMusicStream(music);        // Update music buffer with new stream data
            
            // Restart music playing (stop and play)
            if (IsKeyPressed(KEY_SPACE)) 
            {
                StopMusicStream(music);
                PlayMusicStream(music);
            }
            
            // Pause/Resume music playing 
            if (IsKeyPressed(KEY_P))
            {
                pause = !pause;
                
                if (pause) PauseMusicStream(music);
                else ResumeMusicStream(music);
            }
            
            // Get timePlayed scaled to bar dimensions (400 pixels)
            timePlayed = GetMusicTimePlayed(music)/GetMusicTimeLength(music)*400;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, LIGHTGRAY);
    
                DrawRectangle(200, 200, 400, 12, LIGHTGRAY);
                DrawRectangle(200, 200, (int)timePlayed, 12, MAROON);
                DrawRectangleLines(200, 200, 400, 12, GRAY);
                
                DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, LIGHTGRAY);
                DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadMusicStream(music);   // Unload music stream buffers from RAM
    
        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/audio/audio_raw_stream.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [audio] example - Raw audio streaming
    *
    *   NOTE: This example requires OpenAL Soft library installed
    *
    *   This example has been created using raylib 1.6 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    #include <stdlib.h>         // Required for: malloc(), free()
    #include <math.h>           // Required for: sinf()
    
    #define MAX_SAMPLES             22050
    #define MAX_SAMPLES_PER_UPDATE   4096
    
    public static int audio_raw_stream()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [audio] example - raw audio streaming");
    
        InitAudioDevice();              // Initialize audio device
    
        // Init raw audio stream (sample rate: 22050, sample size: 16bit-short, channels: 1-mono)
        AudioStream stream = InitAudioStream(22050, 16, 1);
        
        // Generate samples data from sine wave
        short *data = (short *)malloc(sizeof(short)*MAX_SAMPLES);
        
        // TODO: Review data generation, it seems data is discontinued for loop,
        // for that reason, there is a clip everytime audio stream is looped...
        for (int i = 0; i < MAX_SAMPLES; i++)
        {
            data[i] = (short)(sinf(((2*PI*(float)i)/2)*DEG2RAD)*32000);
        }
        
        PlayAudioStream(stream);        // Start processing stream buffer (no data loaded currently)
        
        int totalSamples = MAX_SAMPLES;
        int samplesLeft = totalSamples;
        
        Vector2 position = { 0, 0 };
    
        SetTargetFPS(30);               // Set our game to run at 30 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            
            // Refill audio stream if required
            // NOTE: Every update we check if stream data has been already consumed and we update
            // buffer with new data from the generated samples, we upload data at a rate (MAX_SAMPLES_PER_UPDATE),
            // but notice that at some point we update < MAX_SAMPLES_PER_UPDATE data...
            if (IsAudioBufferProcessed(stream)) 
            {
                int numSamples = 0;
                if (samplesLeft >= MAX_SAMPLES_PER_UPDATE) numSamples = MAX_SAMPLES_PER_UPDATE;
                else numSamples = samplesLeft;
    
                UpdateAudioStream(stream, data + (totalSamples - samplesLeft), numSamples);
                
                samplesLeft -= numSamples;
                
                // Reset samples feeding (loop audio)
                if (samplesLeft <= 0) samplesLeft = totalSamples;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("SINE WAVE SHOULD BE PLAYING!", 240, 140, 20, LIGHTGRAY);
                
                // NOTE: Draw a part of the sine wave (only screen width, proportional values)
                for (int i = 0; i < GetScreenWidth(); i++)
                {
                    position.x = i;
                    position.y = 250 + 50*data[i]/32000;
                    
                    DrawPixelV(position, RED);
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        free(data);                 // Unload sine wave data
        
        CloseAudioStream(stream);   // Close raw audio stream and delete buffers from RAM
    
        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/audio/audio_sound_loading.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [audio] example - Sound loading and playing
    *
    *   NOTE: This example requires OpenAL Soft library installed
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int audio_sound_loading()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
    
        InitAudioDevice();      // Initialize audio device
    
        Sound fxWav = LoadSound("resources/sound.wav");         // Load WAV audio file
        Sound fxOgg = LoadSound("resources/tanatana.ogg");      // Load OGG audio file
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyPressed(KEY_SPACE)) PlaySound(fxWav);      // Play WAV sound
            if (IsKeyPressed(KEY_ENTER)) PlaySound(fxOgg);      // Play OGG sound
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, LIGHTGRAY);
    
                DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadSound(fxWav);     // Unload sound data
        UnloadSound(fxOgg);     // Unload sound data
    
        CloseAudioDevice();     // Close audio device
    
        CloseWindow();          // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_3d_camera_first_person.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - 3d camera first person
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    #define MAX_COLUMNS 20
    
    public static int core_3d_camera_first_person()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
        
        // Define the camera to look into our 3d world (position, target, up vector)
        Camera camera = { 0 };
        camera.position = (Vector3){ 4.0f, 2.0f, 4.0f };
        camera.target = (Vector3){ 0.0f, 1.8f, 0.0f };
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
        camera.fovy = 60.0f;
        camera.type = CAMERA_PERSPECTIVE;
    
        // Generates some random columns
        float heights[MAX_COLUMNS];
        Vector3 positions[MAX_COLUMNS];
        Color colors[MAX_COLUMNS];
        
        for (int i = 0; i < MAX_COLUMNS; i++)
        {
            heights[i] = (float)GetRandomValue(1, 12);
            positions[i] = (Vector3){ GetRandomValue(-15, 15), heights[i]/2, GetRandomValue(-15, 15) };
            colors[i] = (Color){ GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255 };
        }
        
        SetCameraMode(camera, CAMERA_FIRST_PERSON); // Set a first person camera mode
    
        SetTargetFPS(60);                           // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())                // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);                  // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawPlane((Vector3){ 0.0f, 0.0f, 0.0f }, (Vector2){ 32.0f, 32.0f }, LIGHTGRAY); // Draw ground
                    DrawCube((Vector3){ -16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, BLUE);     // Draw a blue wall
                    DrawCube((Vector3){ 16.0f, 2.5f, 0.0f }, 1.0f, 5.0f, 32.0f, LIME);      // Draw a green wall
                    DrawCube((Vector3){ 0.0f, 2.5f, 16.0f }, 32.0f, 5.0f, 1.0f, GOLD);      // Draw a yellow wall
                
                    // Draw some cubes around
                    for (int i = 0; i < MAX_COLUMNS; i++)
                    {
                        DrawCube(positions[i], 2.0f, heights[i], 2.0f, colors[i]);
                        DrawCubeWires(positions[i], 2.0f, heights[i], 2.0f, MAROON);
                    }
    
                EndMode3D();
                
                DrawRectangle( 10, 10, 220, 70, Fade(SKYBLUE, 0.5f));
                DrawRectangleLines( 10, 10, 220, 70, BLUE);
    
                DrawText("First person camera default controls:", 20, 20, 10, BLACK);
                DrawText("- Move with keys: W, A, S, D", 40, 40, 10, DARKGRAY);
                DrawText("- Mouse move to look around", 40, 60, 10, DARKGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_3d_camera_free.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Initialize 3d camera free
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_3d_camera_free()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
    
        // Define the camera to look into our 3d world
        Camera3D camera;
        camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
        
        Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
        
        SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
    
        SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())        // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);          // Update camera
            
            if (IsKeyDown('Z')) camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
                
                DrawRectangle( 10, 10, 320, 133, Fade(SKYBLUE, 0.5f));
                DrawRectangleLines( 10, 10, 320, 133, BLUE);
                
                DrawText("Free camera default controls:", 20, 20, 10, BLACK);
                DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, DARKGRAY);
                DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, DARKGRAY);
                DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, DARKGRAY);
                DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, DARKGRAY);
                DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, DARKGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_3d_mode.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Initialize 3d mode
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_3d_mode()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d mode");
    
        // Define the camera to look into our 3d world
        Camera3D camera;
        camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };  // Camera position
        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
    
        Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
    
        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
    
                DrawText("Welcome to the third dimension!", 10, 40, 20, DARKGRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_3d_picking.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Picking in 3d mode
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_3d_picking()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d picking");
    
        // Define the camera to look into our 3d world
        Camera camera;
        camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };      // Camera looking at point
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
    
        Vector3 cubePosition = { 0.0f, 1.0f, 0.0f };
        Vector3 cubeSize = { 2.0f, 2.0f, 2.0f };
    
        Ray ray = {0.0f, 0.0f, 0.0f};        // Picking line ray
    
        bool collision = false;
    
        SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
    
        SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())        // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);          // Update camera
    
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
            {
                ray = GetMouseRay(GetMousePosition(), camera);
    
                // Check collision between ray and box
                collision = CheckCollisionRayBox(ray,
                            (BoundingBox){(Vector3){ cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 },
                                          (Vector3){ cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 }});
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    if (collision)
                    {
                        DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, RED);
                        DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, MAROON);
    
                        DrawCubeWires(cubePosition, cubeSize.x + 0.2f, cubeSize.y + 0.2f, cubeSize.z + 0.2f, GREEN);
                    }
                    else
                    {
                        DrawCube(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, GRAY);
                        DrawCubeWires(cubePosition, cubeSize.x, cubeSize.y, cubeSize.z, DARKGRAY);
                    }
    
                    DrawRay(ray, MAROON);
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
    
                DrawText("Try selecting the box with mouse!", 240, 10, 20, DARKGRAY);
    
                if(collision) DrawText("BOX SELECTED", (screenWidth - MeasureText("BOX SELECTED", 30)) / 2, screenHeight * 0.1f, 30, GREEN);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
-}

ExampleApplication/Examples/core/core_basic_window.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Basic window
    *
    *   Welcome to raylib!
    *
    *   To test examples, just press F6 and execute raylib_compile_execute script
    *   Note that compiled executable is placed in the same folder as .c file
    *
    *   You can find all basic examples on C:\raylib\raylib\examples folder or
    *   raylib official webpage: www.raylib.com
    *
    *   Enjoy using raylib. :)
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_basic_window()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Congrats! You created your first window!", 190, 200, 20, MAROON);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_color_select.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Color selection by mouse (collision detection)
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_color_select()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - color selection (collision detection)");
    
        Color colors[21] = { DARKGRAY, MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, DARKBROWN,
                             GRAY, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, YELLOW,
                             GREEN, SKYBLUE, PURPLE, BEIGE };
    
        Rectangle colorsRecs[21];             // Rectangles array
    
        // Fills colorsRecs data (for every rectangle)
        for (int i = 0; i < 21; i++)
        {
            colorsRecs[i].x = 20 + 100*(i%7) + 10*(i%7);
            colorsRecs[i].y = 60 + 100*(i/7) + 10*(i/7);
            colorsRecs[i].width = 100;
            colorsRecs[i].height = 100;
        }
    
        bool selected[21] = { false };  // Selected rectangles indicator
    
        Vector2 mousePoint;
    
        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            mousePoint = GetMousePosition();
    
            for (int i = 0; i < 21; i++)    // Iterate along all the rectangles
            {
                if (CheckCollisionPointRec(mousePoint, colorsRecs[i]))
                {
                    colors[i].a = 120;
    
                    if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) selected[i] = !selected[i];
                }
                else colors[i].a = 255;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                for (int i = 0; i < 21; i++)    // Draw all rectangles
                {
                    DrawRectangleRec(colorsRecs[i], colors[i]);
    
                    // Draw four rectangles around selected rectangle
                    if (selected[i])
                    {
                        DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 100, 10, RAYWHITE);        // Square top rectangle
                        DrawRectangle(colorsRecs[i].x, colorsRecs[i].y, 10, 100, RAYWHITE);        // Square left rectangle
                        DrawRectangle(colorsRecs[i].x + 90, colorsRecs[i].y, 10, 100, RAYWHITE);   // Square right rectangle
                        DrawRectangle(colorsRecs[i].x, colorsRecs[i].y + 90, 100, 10, RAYWHITE);   // Square bottom rectangle
                    }
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();                // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_drop_files.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Windows drop files
    *
    *   This example only works on platforms that support drag & drop (Windows, Linux, OSX, Html5?)
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_drop_files()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
        
        int count = 0;
        char **droppedFiles = { 0 };
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsFileDropped())
            {
                droppedFiles = GetDroppedFiles(&count);
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                if (count == 0) DrawText("Drop your files to this window!", 100, 40, 20, DARKGRAY);
                else
                {
                    DrawText("Dropped files:", 100, 40, 20, DARKGRAY);
                    
                    for (int i = 0; i < count; i++)
                    {
                        if (i%2 == 0) DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5f));
                        else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3f));
                        
                        DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY);
                    }
                    
                    DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY);
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        ClearDroppedFiles();    // Clear internal buffers
        
        CloseWindow();          // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_input_keys.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Keyboard input
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_input_keys()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
    
        Vector2 ballPosition = { (float)screenWidth/2, (float)screenHeight/2 };
    
        SetTargetFPS(60);       // Set target frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyDown(KEY_RIGHT)) ballPosition.x += 2.0f;
            if (IsKeyDown(KEY_LEFT)) ballPosition.x -= 2.0f;
            if (IsKeyDown(KEY_UP)) ballPosition.y -= 2.0f;
            if (IsKeyDown(KEY_DOWN)) ballPosition.y += 2.0f;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("move the ball with arrow keys", 10, 10, 20, DARKGRAY);
    
                DrawCircleV(ballPosition, 50, MAROON);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_input_mouse.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Mouse input
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_input_mouse()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
    
        Vector2 ballPosition = { -100.0f, -100.0f };
        Color ballColor = DARKBLUE;
        
        SetTargetFPS(60);
        //---------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            ballPosition = GetMousePosition();
            
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ballColor = MAROON;
            else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) ballColor = LIME;
            else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) ballColor = DARKBLUE;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawCircleV(ballPosition, 40, ballColor);
    
                DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_mouse_wheel.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] examples - Mouse wheel
    *
    *   This test has been created using raylib 1.1 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_mouse_wheel()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse wheel");
    
        int boxPositionY = screenHeight/2 - 40;
        int scrollSpeed = 4;            // Scrolling speed in pixels
    
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            boxPositionY -= (GetMouseWheelMove()*scrollSpeed);
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawRectangle(screenWidth/2 - 40, boxPositionY, 80, 80, MAROON);
    
                DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, GRAY);
                DrawText(FormatText("Box position Y: %03i", boxPositionY), 10, 40, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_random_values.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Generate random values
    *
    *   This example has been created using raylib 1.1 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_random_values()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - generate random values");
    
        int framesCounter = 0;  // Variable used to count frames
    
        int randValue = GetRandomValue(-8, 5);   // Get a random integer number between -8 and 5 (both included)
    
        SetTargetFPS(60);       // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            framesCounter++;
    
            // Every two seconds (120 frames) a new random value is generated
            if (((framesCounter/120)%2) == 1)
            {
                randValue = GetRandomValue(-8, 5);
                framesCounter = 0;
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText("Every 2 seconds a new random value is generated:", 130, 100, 20, MAROON);
    
                DrawText(FormatText("%i", randValue), 360, 180, 80, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_storage_values.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - Storage save/load values
    *
    *   This example has been created using raylib 1.4 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    // NOTE: Storage positions must start with 0, directly related to file memory layout
    typedef enum { STORAGE_SCORE = 0, STORAGE_HISCORE } StorageData;
    
    public static int core_storage_values()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - storage save/load values");
        
        int score = 0;
        int hiscore = 0;
        
        int framesCounter = 0;
        
        SetTargetFPS(60);
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyPressed(KEY_R))
            {
                score = GetRandomValue(1000, 2000);
                hiscore = GetRandomValue(2000, 4000);
            }
            
            if (IsKeyPressed(KEY_ENTER))
            {
                StorageSaveValue(STORAGE_SCORE, score);
                StorageSaveValue(STORAGE_HISCORE, hiscore);
            }
            else if (IsKeyPressed(KEY_SPACE))
            {
                // NOTE: If requested position could not be found, value 0 is returned
                score = StorageLoadValue(STORAGE_SCORE);
                hiscore = StorageLoadValue(STORAGE_HISCORE);
            }
            
            framesCounter++;
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                DrawText(FormatText("SCORE: %i", score), 280, 130, 40, MAROON);
                DrawText(FormatText("HI-SCORE: %i", hiscore), 210, 200, 50, BLACK);
                
                DrawText(FormatText("frames: %i", framesCounter), 10, 10, 20, LIME);
                
                DrawText("Press R to generate random numbers", 220, 40, 20, LIGHTGRAY);
                DrawText("Press ENTER to SAVE values", 250, 310, 20, LIGHTGRAY);
                DrawText("Press SPACE to LOAD values", 252, 350, 20, LIGHTGRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------   
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_vr_simulator.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - VR Simulator (Oculus Rift CV1 parameters)
    *
    *   This example has been created using raylib 1.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_vr_simulator()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 1080;
        int screenHeight = 600;
        
        // NOTE: screenWidth/screenHeight should match VR device aspect ratio
        
        InitWindow(screenWidth, screenHeight, "raylib [core] example - vr simulator");
    
        // Init VR simulator (Oculus Rift CV1 parameters)
        InitVrSimulator(GetVrDeviceInfo(HMD_OCULUS_RIFT_CV1));
        
        // Define the camera to look into our 3d world
        Camera camera;
        camera.position = (Vector3){ 5.0f, 2.0f, 5.0f };    // Camera position
        camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };      // Camera looking at point
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
        camera.fovy = 60.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera type
        
        Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
        
        SetCameraMode(camera, CAMERA_FIRST_PERSON);         // Set first person camera mode
        
        SetTargetFPS(90);                   // Set our game to run at 90 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())        // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);          // Update camera (simulator mode)
    
            if (IsKeyPressed(KEY_SPACE)) ToggleVrMode();    // Toggle VR mode
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
                
                BeginVrDrawing();
    
                    BeginMode3D(camera);
    
                        DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                        DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                        DrawGrid(40, 1.0f);
    
                    EndMode3D();
                
                EndVrDrawing();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseVrSimulator();     // Close VR simulator
        
        CloseWindow();          // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/core/core_world_screen.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [core] example - World to screen
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int core_world_screen()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
    
        // Define the camera to look into our 3d world
        Camera camera = { 0 };
        camera.position = (Vector3){ 10.0f, 10.0f, 10.0f };
        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
    
        Vector3 cubePosition = { 0.0f, 0.0f, 0.0f };
        
        Vector2 cubeScreenPosition;
        
        SetCameraMode(camera, CAMERA_FREE); // Set a free camera mode
    
        SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())        // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);          // Update camera
            
            // Calculate cube screen space position (with a little offset to be in top)
            cubeScreenPosition = GetWorldToScreen((Vector3){cubePosition.x, cubePosition.y + 2.5f, cubePosition.z}, camera);
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
                    DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
                
                DrawText("Enemy: 100 / 100", cubeScreenPosition.x - MeasureText("Enemy: 100 / 100", 20) / 2, cubeScreenPosition.y, 20, BLACK);
                DrawText("Text is always on top of the cube", (screenWidth - MeasureText("Text is always on top of the cube", 20)) / 2, 25, 20, GRAY);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/models/models_billboard.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Drawing billboards
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int models_billboard()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - drawing billboards");
    
        // Define the camera to look into our 3d world
        Camera camera = { 0 };
        camera.position = (Vector3){ 5.0f, 4.0f, 5.0f };
        camera.target = (Vector3){ 0.0f, 2.0f, 0.0f };
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
        
    
        Texture2D bill = LoadTexture("resources/billboard.png");     // Our texture billboard
        Vector3 billPosition = { 0.0f, 2.0f, 0.0f };                 // Position where draw billboard
        
        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
    
        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())            // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
                
                    DrawBillboard(camera, bill, billPosition, 2.0f, WHITE);
                    
                    DrawGrid(10, 1.0f);        // Draw a grid
    
                EndMode3D();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(bill);        // Unload texture
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/models/models_cubicmap.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Cubicmap loading and drawing
    *
    *   This example has been created using raylib 1.8 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int models_cubicmap()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - cubesmap loading and drawing");
    
        // Define the camera to look into our 3d world
        Camera camera = {{ 16.0f, 14.0f, 16.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
    
        Image image = LoadImage("resources/cubicmap.png");      // Load cubicmap image (RAM)
        Texture2D cubicmap = LoadTextureFromImage(image);       // Convert image to texture to display (VRAM)
        
        Mesh mesh = GenMeshCubicmap(image, (Vector3){ 1.0f, 1.0f, 1.0f });
        Model model = LoadModelFromMesh(mesh);
        
        // NOTE: By default each cube is mapped to one part of texture atlas
        Texture2D texture = LoadTexture("resources/cubicmap_atlas.png");    // Load map texture
        model.material.maps[MAP_DIFFUSE].texture = texture;                 // Set map diffuse texture
        
        Vector3 mapPosition = { -16.0f, 0.0f, -8.0f };          // Set model position
    
        UnloadImage(image);     // Unload cubesmap image from RAM, already uploaded to VRAM
        
        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
    
        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())            // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, mapPosition, 1.0f, WHITE);
    
                EndMode3D();
                
                DrawTextureEx(cubicmap, (Vector2){ screenWidth - cubicmap.width*4 - 20, 20 }, 0.0f, 4.0f, WHITE);
                DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN);
                
                DrawText("cubicmap image used to", 658, 90, 10, GRAY);
                DrawText("generate map 3d model", 658, 104, 10, GRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(cubicmap);    // Unload cubicmap texture
        UnloadTexture(texture);     // Unload map texture
        UnloadModel(model);         // Unload map model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
-}

ExampleApplication/Examples/models/models_geometric_shapes.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Draw some basic geometric shapes (cube, sphere, cylinder...)
    *
    *   This example has been created using raylib 1.0 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int models_geometric_shapes()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
    
        // Define the camera to look into our 3d world
        Camera camera = { 0 };
        camera.position = (Vector3){ 0.0f, 10.0f, 10.0f };
        camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
        camera.fovy = 45.0f;
        camera.type = CAMERA_PERSPECTIVE;
    
        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            // TODO: Update your variables here
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, RED);
                    DrawCubeWires((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, GOLD);
                    DrawCubeWires((Vector3){-4.0f, 0.0f, -2.0f}, 3.0f, 6.0f, 2.0f, MAROON);
    
                    DrawSphere((Vector3){-1.0f, 0.0f, -2.0f}, 1.0f, GREEN);
                    DrawSphereWires((Vector3){1.0f, 0.0f, 2.0f}, 2.0f, 16, 16, LIME);
    
                    DrawCylinder((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
                    DrawCylinderWires((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
                    DrawCylinderWires((Vector3){4.5f, -1.0f, 2.0f}, 1.0f, 1.0f, 2.0f, 6, BROWN);
    
                    DrawCylinder((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, GOLD);
                    DrawCylinderWires((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, PINK);
    
                    DrawGrid(10, 1.0f);        // Draw a grid
    
                EndMode3D();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/models/models_heightmap.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Heightmap loading and drawing
    *
    *   This example has been created using raylib 1.8 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2015 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int models_heightmap()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
    
        // Define our custom camera to look into our 3d world
        Camera camera = {{ 18.0f, 16.0f, 18.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
    
        Image image = LoadImage("resources/heightmap.png");             // Load heightmap image (RAM)
        Texture2D texture = LoadTextureFromImage(image);                // Convert image to texture (VRAM)
        
        Mesh mesh = GenMeshHeightmap(image, (Vector3){ 16, 8, 16 });    // Generate heightmap mesh (RAM and VRAM)
        Model model = LoadModelFromMesh(mesh);                          // Load model from generated mesh
    
        model.material.maps[MAP_DIFFUSE].texture = texture;             // Set map diffuse texture
        Vector3 mapPosition = { -8.0f, 0.0f, -8.0f };                   // Define model position
    
        UnloadImage(image);                     // Unload heightmap image from RAM, already uploaded to VRAM
        
        SetCameraMode(camera, CAMERA_ORBITAL);  // Set an orbital camera mode
    
        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())            // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, mapPosition, 1.0f, RED);
    
                    DrawGrid(20, 1.0f);
    
                EndMode3D();
                
                DrawTexture(texture, screenWidth - texture.width - 20, 20, WHITE);
                DrawRectangleLines(screenWidth - texture.width - 20, 20, texture.width, texture.height, GREEN);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(texture);     // Unload texture
        UnloadModel(model);         // Unload model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/models/models_mesh_generation.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib example - procedural mesh generation
    *
    *   This example has been created using raylib 1.8 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (Ray San)
    *
    ********************************************************************************************/
    
    
    
    #define NUM_MODELS  7      // We generate 7 parametric 3d shapes
    
    public static int models_mesh_generation()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh generation");
        
        // We generate a checked image for texturing
        Image checked = GenImageChecked(2, 2, 1, 1, RED, GREEN);
        Texture2D texture = LoadTextureFromImage(checked);
        UnloadImage(checked);
        
        Model models[NUM_MODELS];
        
        models[0] = LoadModelFromMesh(GenMeshPlane(2, 2, 5, 5));
        models[1] = LoadModelFromMesh(GenMeshCube(2.0f, 1.0f, 2.0f));
        models[2] = LoadModelFromMesh(GenMeshSphere(2, 32, 32));
        models[3] = LoadModelFromMesh(GenMeshHemiSphere(2, 16, 16));
        models[4] = LoadModelFromMesh(GenMeshCylinder(1, 2, 16));
        models[5] = LoadModelFromMesh(GenMeshTorus(0.25f, 4.0f, 16, 32));
        models[6] = LoadModelFromMesh(GenMeshKnot(1.0f, 2.0f, 16, 128));
        
        // Set checked texture as default diffuse component for all models material
        for (int i = 0; i < NUM_MODELS; i++) models[i].material.maps[MAP_DIFFUSE].texture = texture;
    
        // Define the camera to look into our 3d world
        Camera camera = {{ 5.0f, 5.0f, 5.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
    
        // Model drawing position
        Vector3 position = { 0.0f, 0.0f, 0.0f };
        
        int currentModel = 0;
        
        SetCameraMode(camera, CAMERA_ORBITAL);  // Set a orbital camera mode
    
        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);      // Update internal camera and our camera
            
            if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
            {
                currentModel = (currentModel + 1)%NUM_MODELS; // Cycle between the textures
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(models[currentModel], position, 1.0f, WHITE);
    
                    DrawGrid(10, 1.0);
    
                EndMode3D();
                
                DrawRectangle(30, 400, 310, 30, Fade(SKYBLUE, 0.5f));
                DrawRectangleLines(30, 400, 310, 30, Fade(DARKBLUE, 0.5f));
                DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL MODELS", 40, 410, 10, BLUE);
                
                switch(currentModel)
                {
                    case 0: DrawText("PLANE", 680, 10, 20, DARKBLUE); break;
                    case 1: DrawText("CUBE", 680, 10, 20, DARKBLUE); break;
                    case 2: DrawText("SPHERE", 680, 10, 20, DARKBLUE); break;
                    case 3: DrawText("HEMISPHERE", 640, 10, 20, DARKBLUE); break;
                    case 4: DrawText("CYLINDER", 680, 10, 20, DARKBLUE); break;
                    case 5: DrawText("TORUS", 680, 10, 20, DARKBLUE); break;
                    case 6: DrawText("KNOT", 680, 10, 20, DARKBLUE); break;
                    default: break;
                }
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        
        // Unload models data (GPU VRAM)
        for (int i = 0; i < NUM_MODELS; i++) UnloadModel(models[i]);
        
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/models/models_obj_loading.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Load and draw a 3d model (OBJ)
    *
    *   This example has been created using raylib 1.3 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2014 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int models_obj_loading()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - obj model loading");
    
        // Define the camera to look into our 3d world
        Camera camera = { 0 };
        camera.position = (Vector3){ 8.0f, 8.0f, 8.0f };    // Camera position
        camera.target = (Vector3){ 0.0f, 2.5f, 0.0f };      // Camera looking at point
        camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };          // Camera up vector (rotation towards target)
        camera.fovy = 45.0f;                                // Camera field-of-view Y
        camera.type = CAMERA_PERSPECTIVE;                   // Camera mode type
    
        Model model = LoadModel("resources/models/castle.obj");                 // Load OBJ model
        Texture2D texture = LoadTexture("resources/models/castle_diffuse.png"); // Load model texture
        model.material.maps[MAP_DIFFUSE].texture = texture;                     // Set map diffuse texture
        Vector3 position = { 0.0f, 0.0f, 0.0f };                                // Set model position
    
        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            //...
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(model, position, 0.2f, WHITE);   // Draw 3d model with texture
    
                    DrawGrid(10, 1.0f);         // Draw a grid
    
                    DrawGizmo(position);        // Draw gizmo
    
                EndMode3D();
                
                DrawText("(c) Castle 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadTexture(texture);     // Unload texture
        UnloadModel(model);         // Unload model
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
-}

ExampleApplication/Examples/models/models_orthographic_projection.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Show the difference between perspective and orthographic projection 
    *
    *   This program is heavily based on the geometric objects example
    *
    *   This example has been created using raylib 1.9.7 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2018 Max Danielsson & Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    #define FOVY_PERSPECTIVE    45.0f
    #define WIDTH_ORTHOGRAPHIC  10.0f
    
    public static int models_orthographic_projection()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - geometric shapes");
    
        // Define the camera to look into our 3d world
        Camera camera = {{ 0.0f, 10.0f, 10.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, FOVY_PERSPECTIVE, CAMERA_PERSPECTIVE };
    
        SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())    // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            if (IsKeyPressed(KEY_SPACE)) 
            {
                if (camera.type == CAMERA_PERSPECTIVE) 
                {
                    camera.fovy = WIDTH_ORTHOGRAPHIC;
                    camera.type = CAMERA_ORTHOGRAPHIC;
                } 
                else 
                {
                    camera.fovy = FOVY_PERSPECTIVE;
                    camera.type = CAMERA_PERSPECTIVE;
                }
            }
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawCube((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, RED);
                    DrawCubeWires((Vector3){-4.0f, 0.0f, 2.0f}, 2.0f, 5.0f, 2.0f, GOLD);
                    DrawCubeWires((Vector3){-4.0f, 0.0f, -2.0f}, 3.0f, 6.0f, 2.0f, MAROON);
    
                    DrawSphere((Vector3){-1.0f, 0.0f, -2.0f}, 1.0f, GREEN);
                    DrawSphereWires((Vector3){1.0f, 0.0f, 2.0f}, 2.0f, 16, 16, LIME);
    
                    DrawCylinder((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, SKYBLUE);
                    DrawCylinderWires((Vector3){4.0f, 0.0f, -2.0f}, 1.0f, 2.0f, 3.0f, 4, DARKBLUE);
                    DrawCylinderWires((Vector3){4.5f, -1.0f, 2.0f}, 1.0f, 1.0f, 2.0f, 6, BROWN);
    
                    DrawCylinder((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, GOLD);
                    DrawCylinderWires((Vector3){1.0f, 0.0f, -4.0f}, 0.0f, 1.5f, 3.0f, 8, PINK);
    
                    DrawGrid(10, 1.0f);        // Draw a grid
    
                EndMode3D();
    
                DrawText("Press Spacebar to switch camera type", 10, GetScreenHeight() - 30, 20, DARKGRAY);
    
                if (camera.type == CAMERA_ORTHOGRAPHIC) DrawText("ORTHOGRAPHIC", 10, 40, 20, BLACK);
                else if (camera.type == CAMERA_PERSPECTIVE) DrawText("PERSPECTIVE", 10, 40, 20, BLACK);
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        CloseWindow();        // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
-}

ExampleApplication/Examples/models/models_skybox.cs

@@ -1,8 +0,0 @@
-
-using Raylib;
-using static Raylib.rl;
-
-public partial class Examples
-{
-    /*******************************************************************************************
    *
    *   raylib [models] example - Skybox loading and drawing
    *
    *   This example has been created using raylib 1.8 (www.raylib.com)
    *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
    *
    *   Copyright (c) 2017 Ramon Santamaria (@raysan5)
    *
    ********************************************************************************************/
    
    
    
    public static int models_skybox()
    {
        // Initialization
        //--------------------------------------------------------------------------------------
        int screenWidth = 800;
        int screenHeight = 450;
    
        InitWindow(screenWidth, screenHeight, "raylib [models] example - skybox loading and drawing");
    
        // Define the camera to look into our 3d world
        Camera camera = {{ 1.0f, 1.0f, 1.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f, 0 };
    
        // Load skybox model   
        Mesh cube = GenMeshCube(1.0f, 1.0f, 1.0f);
        Model skybox = LoadModelFromMesh(cube);
        
        // Load skybox shader and set required locations
        // NOTE: Some locations are automatically set at shader loading
        skybox.material.shader = LoadShader("resources/shaders/skybox.vs", "resources/shaders/skybox.fs");
        SetShaderValuei(skybox.material.shader, GetShaderLocation(skybox.material.shader, "environmentMap"), (int[1]){ MAP_CUBEMAP }, 1);
    
        // Load cubemap shader and setup required shader locations
        Shader shdrCubemap = LoadShader("resources/shaders/cubemap.vs", "resources/shaders/cubemap.fs");
        SetShaderValuei(shdrCubemap, GetShaderLocation(shdrCubemap, "equirectangularMap"), (int[1]){ 0 }, 1);
        
        // Load HDR panorama (sphere) texture
        Texture2D texHDR = LoadTexture("resources/dresden_square.hdr");
        
        // Generate cubemap (texture with 6 quads-cube-mapping) from panorama HDR texture
        // NOTE: New texture is generated rendering to texture, shader computes the sphre->cube coordinates mapping
        skybox.material.maps[MAP_CUBEMAP].texture = GenTextureCubemap(shdrCubemap, texHDR, 512);
        
        UnloadTexture(texHDR);      // Texture not required anymore, cubemap already generated
        UnloadShader(shdrCubemap);  // Unload cubemap generation shader, not required anymore
        
        SetCameraMode(camera, CAMERA_FIRST_PERSON);  // Set a first person camera mode
    
        SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
        //--------------------------------------------------------------------------------------
    
        // Main game loop
        while (!WindowShouldClose())            // Detect window close button or ESC key
        {
            // Update
            //----------------------------------------------------------------------------------
            UpdateCamera(&camera);              // Update camera
            //----------------------------------------------------------------------------------
    
            // Draw
            //----------------------------------------------------------------------------------
            BeginDrawing();
    
                ClearBackground(RAYWHITE);
    
                BeginMode3D(camera);
    
                    DrawModel(skybox, (Vector3){0, 0, 0}, 1.0f, WHITE);
                    
                    DrawGrid(10, 1.0f);
    
                EndMode3D();
    
                DrawFPS(10, 10);
    
            EndDrawing();
            //----------------------------------------------------------------------------------
        }
    
        // De-Initialization
        //--------------------------------------------------------------------------------------
        UnloadModel(skybox);        // Unload skybox model (and textures)
    
        CloseWindow();              // Close window and OpenGL context
        //--------------------------------------------------------------------------------------
    
        return 0;
    }
    
-}