quartznet/raylib-cs
2
0
Fork 0
mirror of https://github.com/raylib-cs/raylib-cs synced 2025-04-03 11:09:40 -04:00
Code Activity

Alot of binding improvements!

Browse Source 
- 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.
This commit is contained in:
ChrisDill 2018-08-31 09:30:32 +01:00
parent ac9fb34f79
commit 509ddf233f
282 changed files with 595 additions and 3747 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

0
ExampleApplication/App.config → Bindings/App.config
View File

0
ExampleApplication/ExampleApplication.csproj → Bindings/Bindings.csproj
View File

0
ExampleApplication/DrawControl.cs → Bindings/DrawControl.cs
View File

0
ExampleApplication/DrawControl.resx → Bindings/DrawControl.resx
View File

112
Bindings/Easings.cs Normal file
View File

@ -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
}
}

0
ExampleApplication/Physac.cs → Bindings/Physac.cs
View File

11
Bindings/Program.cs Normal file
View File

@ -0,0 +1,11 @@

namespace Bindings
{
static class Program
{
static void Main(string[] args)
{
Examples.core_basic_window();
}
}
}

0
ExampleApplication/Properties/AssemblyInfo.cs → Bindings/Properties/AssemblyInfo.cs
View File

361
Bindings/Raygui.cs Normal file
View File

@ -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
}
}

4
ExampleApplication/Raylib.cs → Bindings/Raylib.cs
View File

@ -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

53
ExampleApplication/Raymath.cs → Bindings/Raymath.cs
View File

@ -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);

0
ExampleApplication/Rlgl.cs → Bindings/Rlgl.cs
View File

BIN
Bindings/bin/Debug/ExampleApplication.exe Normal file
View File

Binary file not shown.

0
ExampleApplication/bin/Debug/ExampleApplication.exe.config → Bindings/bin/Debug/ExampleApplication.exe.config
View File

BIN
ExampleApplication/bin/Debug/x64/raylib.dll → Bindings/bin/Debug/raylib.dll
View File

Binary file not shown.

1
Bindings/core_basic_window.cs Normal file
View File

@ -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; } }

27
ExampleApplication/Easings.cs
View File

@ -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
}
}

8
ExampleApplication/Examples/audio/audio_module_playing.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/audio/audio_module_playing.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 47 KiB

8
ExampleApplication/Examples/audio/audio_music_stream.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/audio/audio_music_stream.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

8
ExampleApplication/Examples/audio/audio_raw_stream.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/audio/audio_raw_stream.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 16 KiB

8
ExampleApplication/Examples/audio/audio_sound_loading.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/audio/audio_sound_loading.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

8
ExampleApplication/Examples/core/core_2d_camera.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/core/core_2d_camera.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 21 KiB

8
ExampleApplication/Examples/core/core_3d_camera_first_person.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_3d_camera_first_person.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 17 KiB

8
ExampleApplication/Examples/core/core_3d_camera_free.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_3d_camera_free.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 25 KiB

8
ExampleApplication/Examples/core/core_3d_mode.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_3d_mode.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 8.3 KiB

8
ExampleApplication/Examples/core/core_3d_picking.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_3d_picking.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 24 KiB

8
ExampleApplication/Examples/core/core_basic_window.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_basic_window.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 10 KiB

8
ExampleApplication/Examples/core/core_color_select.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_color_select.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 14 KiB

8
ExampleApplication/Examples/core/core_drop_files.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_drop_files.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.6 KiB

8
ExampleApplication/Examples/core/core_gestures_detection.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/core/core_gestures_detection.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 19 KiB

8
ExampleApplication/Examples/core/core_input_gamepad.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/core/core_input_gamepad.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 37 KiB

8
ExampleApplication/Examples/core/core_input_keys.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_input_keys.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 10 KiB

8
ExampleApplication/Examples/core/core_input_mouse.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_input_mouse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

8
ExampleApplication/Examples/core/core_mouse_wheel.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_mouse_wheel.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

8
ExampleApplication/Examples/core/core_random_values.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_random_values.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 15 KiB

8
ExampleApplication/Examples/core/core_storage_values.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_storage_values.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 16 KiB

8
ExampleApplication/Examples/core/core_vr_simulator.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_vr_simulator.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 173 KiB

8
ExampleApplication/Examples/core/core_world_screen.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/core/core_world_screen.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

BIN
ExampleApplication/Examples/models/bridge_diffuse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 311 KiB

BIN
ExampleApplication/Examples/models/castle_diffuse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 1.5 MiB

BIN
ExampleApplication/Examples/models/house_diffuse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 384 KiB

BIN
ExampleApplication/Examples/models/market_diffuse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 381 KiB

8
ExampleApplication/Examples/models/models_billboard.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_billboard.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 54 KiB

8
ExampleApplication/Examples/models/models_box_collisions.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/models/models_box_collisions.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 22 KiB

8
ExampleApplication/Examples/models/models_cubicmap.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_cubicmap.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 403 KiB

8
ExampleApplication/Examples/models/models_geometric_shapes.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_geometric_shapes.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 33 KiB

8
ExampleApplication/Examples/models/models_heightmap.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_heightmap.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 95 KiB

8
ExampleApplication/Examples/models/models_material_pbr.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/models/models_material_pbr.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 317 KiB

8
ExampleApplication/Examples/models/models_mesh_generation.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_mesh_generation.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 27 KiB

8
ExampleApplication/Examples/models/models_mesh_picking.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/models/models_mesh_picking.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 136 KiB

8
ExampleApplication/Examples/models/models_obj_loading.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_obj_loading.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 260 KiB

8
ExampleApplication/Examples/models/models_orthographic_projection.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_orthographic_projection.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 32 KiB

8
ExampleApplication/Examples/models/models_skybox.cs
View File

@ -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; }
}

BIN
ExampleApplication/Examples/models/models_skybox.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 417 KiB

8
ExampleApplication/Examples/models/models_yaw_pitch_roll.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/models/models_yaw_pitch_roll.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 180 KiB

BIN
ExampleApplication/Examples/models/turret_diffuse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 372 KiB

BIN
ExampleApplication/Examples/models/well_diffuse.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 335 KiB

8
ExampleApplication/Examples/physac/physics_demo.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/physac/physics_demo.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

8
ExampleApplication/Examples/physac/physics_friction.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/physac/physics_friction.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 18 KiB

8
ExampleApplication/Examples/physac/physics_movement.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/physac/physics_movement.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 16 KiB

8
ExampleApplication/Examples/physac/physics_restitution.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/physac/physics_restitution.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 17 KiB

8
ExampleApplication/Examples/physac/physics_shatter.cs
View File

File diff suppressed because one or more lines are too long

BIN
ExampleApplication/Examples/physac/physics_shatter.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 23 KiB

8
ExampleApplication/Examples/shaders/shaders_custom_uniform.cs
View File

File diff suppressed because one or more lines are too long

Some files were not shown because too many files have changed in this diff Show More