From 86d5d74445192160d3591b35293fbb6032949c16 Mon Sep 17 00:00:00 2001 From: nub31 Date: Sun, 28 Sep 2025 19:43:25 +0200 Subject: [PATCH] raylib bindings started --- example/makefile | 8 +- example/src/main.nub | 20 +- example/src/raylib.nub | 1502 ++++++++++++++++++++++++++++++++++++++++ example/src/ref.nub | 40 -- 4 files changed, 1515 insertions(+), 55 deletions(-) create mode 100644 example/src/raylib.nub delete mode 100644 example/src/ref.nub diff --git a/example/makefile b/example/makefile index 0a4e657..9632755 100644 --- a/example/makefile +++ b/example/makefile @@ -1,12 +1,12 @@ NUBC = ../compiler/NubLang.CLI/bin/Debug/net9.0/nubc out: .build/out.o - gcc -nostartfiles -o out x86_64.s .build/out.o + gcc -nostartfiles -lm -o out x86_64.s .build/out.o vendor/raylib-5.5_linux_amd64/lib/libraylib.a -.build/out.o: $(NUBC) src/main.nub src/ref.nub - $(NUBC) src/main.nub src/ref.nub +.build/out.o: $(NUBC) src/main.nub src/raylib.nub + $(NUBC) src/main.nub src/raylib.nub -.PHONY: $(NUBC) +# .PHONY: $(NUBC) $(NUBC): dotnet build ../compiler/NubLang.CLI/NubLang.CLI.csproj diff --git a/example/src/main.nub b/example/src/main.nub index c989628..8c210d6 100644 --- a/example/src/main.nub +++ b/example/src/main.nub @@ -1,19 +1,17 @@ import "core" +import "raylib" module "main" -struct Human -{ - name: cstring -} - extern "main" func main(args: []cstring): i64 { - let x: core::ref = {} - test(x) - return 0 -} + raylib::InitWindow(1600, 900, "Hi from nub-lang") -func test(x: core::ref) -{ + while !raylib::WindowShouldClose() + { + raylib::BeginDrawing() + raylib::EndDrawing() + } + + return 0 } \ No newline at end of file diff --git a/example/src/raylib.nub b/example/src/raylib.nub new file mode 100644 index 0000000..06c4f35 --- /dev/null +++ b/example/src/raylib.nub @@ -0,0 +1,1502 @@ +module "raylib" + +// export let PI = 3.14159265358979323846 + +// export let LIGHTGRAY = struct Color { r = 200, g = 200, b = 200, a = 255 } +// export let GRAY = struct Color { r = 130, g = 130, b = 130, a = 255 } +// export let DARKGRAY = struct Color { r = 80, g = 80, b = 80, a = 255 } +// export let YELLOW = struct Color { r = 253, g = 249, b = 0, a = 255 } +// export let GOLD = struct Color { r = 255, g = 203, b = 0, a = 255 } +// export let ORANGE = struct Color { r = 255, g = 161, b = 0, a = 255 } +// export let PINK = struct Color { r = 255, g = 109, b = 194, a = 255 } +// export let RED = struct Color { r = 230, g = 41, b = 55, a = 255 } +// export let MAROON = struct Color { r = 190, g = 33, b = 55, a = 255 } +// export let GREEN = struct Color { r = 0, g = 228, b = 48, a = 255 } +// export let LIME = struct Color { r = 0, g = 158, b = 47, a = 255 } +// export let DARKGREEN = struct Color { r = 0, g = 117, b = 44, a = 255 } +// export let SKYBLUE = struct Color { r = 102, g = 191, b = 255, a = 255 } +// export let BLUE = struct Color { r = 0, g = 121, b = 241, a = 255 } +// export let DARKBLUE = struct Color { r = 0, g = 82, b = 172, a = 255 } +// export let PURPLE = struct Color { r = 200, g = 122, b = 255, a = 255 } +// export let VIOLET = struct Color { r = 135, g = 60, b = 190, a = 255 } +// export let DARKPURPLE = struct Color { r = 112, g = 31, b = 126, a = 255 } +// export let BEIGE = struct Color { r = 211, g = 176, b = 131, a = 255 } +// export let BROWN = struct Color { r = 127, g = 106, b = 79, a = 255 } +// export let DARKBROWN = struct Color { r = 76, g = 63, b = 47, a = 255 } + +// export let WHITE = struct Color { r = 255, g = 255, b = 255, a = 255 } +// export let BLACK = struct Color { r = 0, g = 0, b = 0, a = 255 } +// export let BLANK = struct Color { r = 0, g = 0, b = 0, a = 0 } +// export let MAGENTA = struct Color { r = 255, g = 0, b = 255, a = 255 } +// export let RAYWHITE = struct Color { r = 245, g = 245, b = 245, a = 255 } + +export struct Vector2 +{ + x: f32 + y: f32 +} + +export struct Vector3 +{ + x: f32 + y: f32 + z: f32 +} + +export struct Vector4 +{ + x: f32 + y: f32 + z: f32 + w: f32 +} + +export struct Quaternion +{ + x: f32 + y: f32 + z: f32 + w: f32 +} + +export struct Matrix +{ + m0: f32 + m1: f32 + m2: f32 + m3: f32 + m4: f32 + m5: f32 + m6: f32 + m7: f32 + m8: f32 + m9: f32 + m10: f32 + m11: f32 + m12: f32 + m13: f32 + m14: f32 + m15: f32 +} + +export struct Color +{ + r: u8 + g: u8 + b: u8 + a: u8 +} + +export struct Rectangle +{ + x: f32 + y: f32 + width: f32 + height: f32 +} + +export struct Image +{ + data: ^void + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} + +export struct Texture +{ + id: u32 + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} + +export struct Texture2D +{ + id: u32 + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} + +export struct TextureCubemap +{ + id: u32 + width: i32 + height: i32 + mipmaps: i32 + format: i32 +} + +export struct RenderTexture +{ + id: u32 + texture: Texture + depth: Texture +} + +export struct RenderTexture2D +{ + id: u32 + texture: Texture + depth: Texture +} + +export struct NPatchInfo +{ + source: Rectangle + left: i32 + top: i32 + right: i32 + bottom: i32 + layout: i32 +} + +export struct GlyphInfo +{ + value: i32 + offsetX: i32 + offsetY: i32 + advanceX: i32 + image: Image +} + +export struct Font +{ + baseSize: i32 + glyphCount: i32 + glyphPadding: i32 + texture: Texture2D + recs: ^Rectangle + glyphs: ^GlyphInfo +} + +export struct Camera3D +{ + position: Vector3 + target: Vector3 + up: Vector3 + fovy: f32 + projection: i32 +} + +export struct Camera +{ + position: Vector3 + target: Vector3 + up: Vector3 + fovy: f32 + projection: i32 +} + +export struct Camera2D +{ + offset: Vector2 + target: Vector2 + rotation: f32 + zoom: f32 +} + +export struct Mesh +{ + vertexCount: i32 + triangleCount: i32 + + vertices: ^f32 + texcoords: ^f32 + texcoords2: ^f32 + normals: ^f32 + tangents: ^f32 + colors: ^u8 + indices: ^u16 + + animVertices: ^f32 + animNormals: ^f32 + boneIds: ^u8 + boneWeights: ^f32 + boneMatrices: ^Matrix + boneCount: i32 + + vaoId: u32 + vboId: ^u32 +} + +export struct Shader +{ + id: u32 + locs: ^i32 +} + +export struct MaterialMap +{ + texture: Texture2D + color: Color + value: f32 +} + +// export struct Material +// { +// shader: Shader +// maps: ^MaterialMap +// params: [4]float +// } + +export struct Transform +{ + translation: Vector3 + rotation: Quaternion + scale: Vector3 +} + +// export struct BoneInfo +// { +// name: [32]u8 +// parent: i32 +// } + +// export struct Model +// { +// transform: Matrix + +// meshCount: i32 +// materialCount: i32 +// meshes: ^Mesh +// materials: ^Material +// meshMaterial: ^int + +// boneCount: int +// bones: ^BoneInfo +// bindPose: ^Transform +// } + +// export struct ModelAnimation +// { +// boneCount: i32 +// frameCount: i32 +// bones: ^BoneInfo +// framePoses: ^^Transform +// name: [32]u8 +// } + +export struct Ray +{ + position: Vector3 + direction: Vector3 +} + +export struct RayCollision +{ + hit: bool + distance: f32 + point: Vector3 + normal: Vector3 +} + +export struct BoundingBox +{ + min: Vector3 + max: Vector3 +} + +// export struct Wave +// { +// frameCount: u32; +// sampleRate: u32; +// sampleSize: u32; +// channels: u32; +// data: ^void; +// } + +// // Opaque structs declaration +// // NOTE: Actual structs are defined internally in raudio module +// typedef struct rAudioBuffer rAudioBuffer; +// typedef struct rAudioProcessor rAudioProcessor; + +// // AudioStream, custom audio stream +// typedef struct AudioStream { +// rAudioBuffer *buffer; // Pointer to internal data used by the audio system +// rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects + +// unsigned int sampleRate; // Frequency (samples per second) +// unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported) +// unsigned int channels; // Number of channels (1-mono, 2-stereo, ...) +// } AudioStream; + +// // Sound +// typedef struct Sound { +// AudioStream stream; // Audio stream +// unsigned int frameCount; // Total number of frames (considering channels) +// } Sound; + +// // Music, audio stream, anything longer than ~10 seconds should be streamed +// typedef struct Music { +// AudioStream stream; // Audio stream +// unsigned int frameCount; // Total number of frames (considering channels) +// bool looping; // Music looping enable + +// int ctxType; // Type of music context (audio filetype) +// void *ctxData; // Audio context data, depends on type +// } Music; + +// // VrDeviceInfo, Head-Mounted-Display device parameters +// typedef struct VrDeviceInfo { +// int hResolution; // Horizontal resolution in pixels +// int vResolution; // Vertical resolution in pixels +// float hScreenSize; // Horizontal size in meters +// float vScreenSize; // Vertical size in meters +// float eyeToScreenDistance; // Distance between eye and display in meters +// float lensSeparationDistance; // Lens separation distance in meters +// float interpupillaryDistance; // IPD (distance between pupils) in meters +// float lensDistortionValues[4]; // Lens distortion constant parameters +// float chromaAbCorrection[4]; // Chromatic aberration correction parameters +// } VrDeviceInfo; + +// // VrStereoConfig, VR stereo rendering configuration for simulator +// typedef struct VrStereoConfig { +// Matrix projection[2]; // VR projection matrices (per eye) +// Matrix viewOffset[2]; // VR view offset matrices (per eye) +// float leftLensCenter[2]; // VR left lens center +// float rightLensCenter[2]; // VR right lens center +// float leftScreenCenter[2]; // VR left screen center +// float rightScreenCenter[2]; // VR right screen center +// float scale[2]; // VR distortion scale +// float scaleIn[2]; // VR distortion scale in +// } VrStereoConfig; + +// // File path list +// typedef struct FilePathList { +// unsigned int capacity; // Filepaths max entries +// unsigned int count; // Filepaths entries count +// char **paths; // Filepaths entries +// } FilePathList; + +// // Automation event +// typedef struct AutomationEvent { +// unsigned int frame; // Event frame +// unsigned int type; // Event type (AutomationEventType) +// int params[4]; // Event parameters (if required) +// } AutomationEvent; + +// // Automation event list +// typedef struct AutomationEventList { +// unsigned int capacity; // Events max entries (MAX_AUTOMATION_EVENTS) +// unsigned int count; // Events entries count +// AutomationEvent *events; // Events entries +// } AutomationEventList; + +// export enum ConfigFlags +// { +// VSYNC_HINT = 0x00000040 +// FULLSCREEN_MODE = 0x00000002 +// WINDOW_RESIZABLE = 0x00000004 +// WINDOW_UNDECORATED = 0x00000008 +// WINDOW_HIDDEN = 0x00000080 +// WINDOW_MINIMIZED = 0x00000200 +// WINDOW_MAXIMIZED = 0x00000400 +// WINDOW_UNFOCUSED = 0x00000800 +// WINDOW_TOPMOST = 0x00001000 +// WINDOW_ALWAYS_RUN = 0x00000100 +// WINDOW_TRANSPARENT = 0x00000010 +// WINDOW_HIGHDPI = 0x00002000 +// WINDOW_MOUSE_PASSTHROUGH = 0x00004000 +// BORDERLESS_WINDOWED_MODE = 0x00008000 +// MSAA_4X_HINT = 0x00000020 +// INTERLACED_HINT = 0x00010000 +// } + + +// export enum TraceLogLevel +// { +// LOG_ALL = 0 +// LOG_TRACE +// LOG_DEBUG +// LOG_INFO +// LOG_WARNING +// LOG_ERROR +// LOG_FATAL +// LOG_NONE +// } + +// export enum KeyboardKey +// { +// NULL = 0 +// APOSTROPHE = 39 +// COMMA = 44 +// MINUS = 45 +// PERIOD = 46 +// SLASH = 47 +// ZERO = 48 +// ONE = 49 +// TWO = 50 +// THREE = 51 +// FOUR = 52 +// FIVE = 53 +// SIX = 54 +// SEVEN = 55 +// EIGHT = 56 +// NINE = 57 +// SEMICOLON = 59 +// EQUAL = 61 +// A = 65 +// B = 66 +// C = 67 +// D = 68 +// E = 69 +// F = 70 +// G = 71 +// H = 72 +// I = 73 +// J = 74 +// K = 75 +// L = 76 +// M = 77 +// N = 78 +// O = 79 +// P = 80 +// Q = 81 +// R = 82 +// S = 83 +// T = 84 +// U = 85 +// V = 86 +// W = 87 +// X = 88 +// Y = 89 +// Z = 90 +// LEFT_BRACKET = 91 +// BACKSLASH = 92 +// RIGHT_BRACKET = 93 +// GRAVE = 96 +// SPACE = 32 +// ESCAPE = 256 +// ENTER = 257 +// TAB = 258 +// BACKSPACE = 259 +// INSERT = 260 +// DELETE = 261 +// RIGHT = 262 +// LEFT = 263 +// DOWN = 264 +// UP = 265 +// PAGE_UP = 266 +// PAGE_DOWN = 267 +// HOME = 268 +// END = 269 +// CAPS_LOCK = 280 +// SCROLL_LOCK = 281 +// NUM_LOCK = 282 +// PRINT_SCREEN = 283 +// PAUSE = 284 +// F1 = 290 +// F2 = 291 +// F3 = 292 +// F4 = 293 +// F5 = 294 +// F6 = 295 +// F7 = 296 +// F8 = 297 +// F9 = 298 +// F10 = 299 +// F11 = 300 +// F12 = 301 +// LEFT_SHIFT = 340 +// LEFT_CONTROL = 341 +// LEFT_ALT = 342 +// LEFT_SUPER = 343 +// RIGHT_SHIFT = 344 +// RIGHT_CONTROL = 345 +// RIGHT_ALT = 346 +// RIGHT_SUPER = 347 +// KB_MENU = 348 +// KP_0 = 320 +// KP_1 = 321 +// KP_2 = 322 +// KP_3 = 323 +// KP_4 = 324 +// KP_5 = 325 +// KP_6 = 326 +// KP_7 = 327 +// KP_8 = 328 +// KP_9 = 329 +// KP_DECIMAL = 330 +// KP_DIVIDE = 331 +// KP_MULTIPLY = 332 +// KP_SUBTRACT = 333 +// KP_ADD = 334 +// KP_ENTER = 335 +// KP_EQUAL = 336 +// BACK = 4 +// MENU = 5 +// VOLUME_UP = 24 +// VOLUME_DOWN = 25 +// } + +// export enum MouseButton +// { +// LEFT = 0 +// RIGHT = 1 +// MIDDLE = 2 +// SIDE = 3 +// EXTRA = 4 +// FORWARD = 5 +// BACK = 6 +// } + +// export enum MouseCursor +// { +// DEFAULT = 0 +// ARROW = 1 +// IBEAM = 2 +// CROSSHAIR = 3 +// POINTING_HAND = 4 +// RESIZE_EW = 5 +// RESIZE_NS = 6 +// RESIZE_NWSE = 7 +// RESIZE_NESW = 8 +// RESIZE_ALL = 9 +// NOT_ALLOWED = 10 +// } + +// export enum GamepadButton +// { +// UNKNOWN = 0 +// LEFT_FACE_UP +// LEFT_FACE_RIGHT +// LEFT_FACE_DOWN +// LEFT_FACE_LEFT +// RIGHT_FACE_UP +// RIGHT_FACE_RIGHT +// RIGHT_FACE_DOWN +// RIGHT_FACE_LEFT +// LEFT_TRIGGER_1 +// LEFT_TRIGGER_2 +// RIGHT_TRIGGER_1 +// RIGHT_TRIGGER_2 +// MIDDLE_LEFT +// MIDDLE +// MIDDLE_RIGHT +// LEFT_THUMB +// RIGHT_THUMB +// } + +// export enum GamepadAxis +// { +// LEFT_X = 0 +// LEFT_Y = 1 +// RIGHT_X = 2 +// RIGHT_Y = 3 +// LEFT_TRIGGER = 4 +// RIGHT_TRIGGER = 5 +// } + +// export enum MaterialMapIndex +// { +// ALBEDO = 0 +// METALNESS +// NORMAL +// ROUGHNESS +// OCCLUSION +// EMISSION +// HEIGHT +// CUBEMAP +// IRRADIANCE +// PREFILTER +// BRDF +// } + +// export enum ShaderLocationIndex +// { +// VERTEX_POSITION = 0 +// VERTEX_TEXCOORD01 +// VERTEX_TEXCOORD02 +// VERTEX_NORMAL +// VERTEX_TANGENT +// VERTEX_COLOR +// MATRIX_MVP +// MATRIX_VIEW +// MATRIX_PROJECTION +// MATRIX_MODEL +// MATRIX_NORMAL +// VECTOR_VIEW +// COLOR_DIFFUSE +// COLOR_SPECULAR +// COLOR_AMBIENT +// MAP_ALBEDO +// MAP_METALNESS +// MAP_NORMAL +// MAP_ROUGHNESS +// MAP_OCCLUSION +// MAP_EMISSION +// MAP_HEIGHT +// MAP_CUBEMAP +// MAP_IRRADIANCE +// MAP_PREFILTER +// MAP_BRDF +// VERTEX_BONEIDS +// VERTEX_BONEWEIGHTS +// BONE_MATRICES +// } + +// export enum ShaderUniformDataType { +// FLOAT = 0 +// VEC2 +// VEC3 +// VEC4 +// INT +// IVEC2 +// IVEC3 +// IVEC4 +// SAMPLER2D +// } + +// export enum ShaderAttributeDataType { +// FLOAT = 0 +// VEC2 +// VEC3 +// VEC4 +// } + +// export enum PixelFormat +// { +// UNCOMPRESSED_GRAYSCALE = 1 +// UNCOMPRESSED_GRAY_ALPHA +// UNCOMPRESSED_R5G6B5 +// UNCOMPRESSED_R8G8B8 +// UNCOMPRESSED_R5G5B5A1 +// UNCOMPRESSED_R4G4B4A4 +// UNCOMPRESSED_R8G8B8A8 +// UNCOMPRESSED_R32 +// UNCOMPRESSED_R32G32B32 +// UNCOMPRESSED_R32G32B32A32 +// UNCOMPRESSED_R16 +// UNCOMPRESSED_R16G16B16 +// UNCOMPRESSED_R16G16B16A16 +// COMPRESSED_DXT1_RGB +// COMPRESSED_DXT1_RGBA +// COMPRESSED_DXT3_RGBA +// COMPRESSED_DXT5_RGBA +// COMPRESSED_ETC1_RGB +// COMPRESSED_ETC2_RGB +// COMPRESSED_ETC2_EAC_RGBA +// COMPRESSED_PVRT_RGB +// COMPRESSED_PVRT_RGBA +// COMPRESSED_ASTC_4x4_RGBA +// COMPRESSED_ASTC_8x8_RGBA +// } + +// export enum TextureFilter +// { +// POINT = 0 +// BILINEAR +// TRILINEAR +// ANISOTROPIC_4X +// ANISOTROPIC_8X +// ANISOTROPIC_16X +// } + +// export enum TextureWrap +// { +// REPEAT = 0 +// CLAMP +// MIRROR_REPEAT +// MIRROR_CLAMP +// } + +// export enum CubemapLayout +// { +// AUTO_DETECT = 0 +// LINE_VERTICAL +// LINE_HORIZONTAL +// CROSS_THREE_BY_FOUR +// CROSS_FOUR_BY_THREE +// } + +// export enum FontType +// { +// FONT_DEFAULT = 0 +// FONT_BITMAP +// FONT_SDF +// } + +// export enum BlendMode +// { +// BLEND_ALPHA = 0, +// BLEND_ADDITIVE, +// BLEND_MULTIPLIED, +// BLEND_ADD_COLORS, +// BLEND_SUBTRACT_COLORS, +// BLEND_ALPHA_PREMULTIPLY, +// BLEND_CUSTOM, +// BLEND_CUSTOM_SEPARATE +// } + +// export enum Gesture +// { +// GESTURE_NONE = 0 +// GESTURE_TAP = 1 +// GESTURE_DOUBLETAP = 2 +// GESTURE_HOLD = 4 +// GESTURE_DRAG = 8 +// GESTURE_SWIPE_RIGHT = 16 +// GESTURE_SWIPE_LEFT = 32 +// GESTURE_SWIPE_UP = 64 +// GESTURE_SWIPE_DOWN = 128 +// GESTURE_PINCH_IN = 256 +// GESTURE_PINCH_OUT = 512 +// } + +// export enum CameraMode +// { +// CAMERA_CUSTOM = 0 +// CAMERA_FREE +// CAMERA_ORBITAL +// CAMERA_FIRST_PERSON +// CAMERA_THIRD_PERSON +// } + +// export enum CameraProjection +// { +// CAMERA_PERSPECTIVE = 0 +// CAMERA_ORTHOGRAPHIC +// } + +// export enum NPatchLayout +// { +// NPATCH_NINE_PATCH = 0 +// NPATCH_THREE_PATCH_VERTICAL +// NPATCH_THREE_PATCH_HORIZONTAL +// } + +// // Callbacks to hook some internal functions +// // WARNING: These callbacks are intended for advanced users +// typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args); // Logging: Redirect trace log messages +// typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize); // FileIO: Load binary data +// typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize); // FileIO: Save binary data +// typedef char *(*LoadFileTextCallback)(const char *fileName); // FileIO: Load text data +// typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data + +export extern "InitWindow" func InitWindow(width: i32, height: i32, title: cstring) +export extern "CloseWindow" func CloseWindow() +export extern "WindowShouldClose" func WindowShouldClose(): bool +export extern "IsWindowReady" func IsWindowReady(): bool +export extern "IsWindowFullscreen" func IsWindowFullscreen(): bool +export extern "IsWindowHidden" func IsWindowHidden(): bool +export extern "IsWindowMinimized" func IsWindowMinimized(): bool +export extern "IsWindowMaximized" func IsWindowMaximized(): bool +export extern "IsWindowFocused" func IsWindowFocused(): bool +export extern "IsWindowResized" func IsWindowResized(): bool +export extern "IsWindowState" func IsWindowState(flag: u32): bool +export extern "SetWindowState" func SetWindowState(flags: u32) +export extern "ClearWindowState" func ClearWindowState(flags: u32) +export extern "ToggleFullscreen" func ToggleFullscreen() +export extern "ToggleBorderlessWindowed" func ToggleBorderlessWindowed() +export extern "MaximizeWindow" func MaximizeWindow() +export extern "MinimizeWindow" func MinimizeWindow() +export extern "RestoreWindow" func RestoreWindow() +export extern "SetWindowIcon" func SetWindowIcon(image: Image) +export extern "SetWindowIcons" func SetWindowIcons(images: ^Image, count: i32) +export extern "SetWindowTitle" func SetWindowTitle(title: cstring) +export extern "SetWindowPosition" func SetWindowPosition(x: i32, y: i32) +export extern "SetWindowMonitor" func SetWindowMonitor(monitor: i32) +export extern "SetWindowMinSize" func SetWindowMinSize(width: i32, height: i32) +export extern "SetWindowMaxSize" func SetWindowMaxSize(width: i32, height: i32) +export extern "SetWindowSize" func SetWindowSize(width: i32, height: i32) +export extern "SetWindowOpacity" func SetWindowOpacity(opacity: f32) +export extern "SetWindowFocused" func SetWindowFocused() +export extern "*GetWindowHandle" func GetWindowHandle(): ^void +export extern "GetScreenWidth" func GetScreenWidth(): i32 +export extern "GetScreenHeight" func GetScreenHeight(): i32 +export extern "GetRenderWidth" func GetRenderWidth(): i32 +export extern "GetRenderHeight" func GetRenderHeight(): i32 +export extern "GetMonitorCount" func GetMonitorCount(): i32 +export extern "GetCurrentMonitor" func GetCurrentMonitor(): i32 +export extern "GetMonitorPosition" func GetMonitorPosition(monitor: i32): Vector2 +export extern "GetMonitorWidth" func GetMonitorWidth(monitor: i32): i32 +export extern "GetMonitorHeight" func GetMonitorHeight(monitor: i32): i32 +export extern "GetMonitorPhysicalWidth" func GetMonitorPhysicalWidth(monitor: i32): i32 +export extern "GetMonitorPhysicalHeight" func GetMonitorPhysicalHeight(monitor: i32): i32 +export extern "GetMonitorRefreshRate" func GetMonitorRefreshRate(monitor: i32): i32 +export extern "GetWindowPosition" func GetWindowPosition(): Vector2 +export extern "GetWindowScaleDPI" func GetWindowScaleDPI(): Vector2 +export extern "GetMonitorName" func GetMonitorName(monitor: i32): cstring +export extern "SetClipboardText" func SetClipboardText(text: cstring) +export extern "GetClipboardText" func GetClipboardText(): cstring +export extern "GetClipboardImage" func GetClipboardImage(): Image +export extern "EnableEventWaiting" func EnableEventWaiting() +export extern "DisableEventWaiting" func DisableEventWaiting() + +export extern "ShowCursor" func ShowCursor() +export extern "HideCursor" func HideCursor() +export extern "IsCursorHidden" func IsCursorHidden(): bool +export extern "EnableCursor" func EnableCursor() +export extern "DisableCursor" func DisableCursor() +export extern "IsCursorOnScreen" func IsCursorOnScreen(): bool + +export extern "ClearBackground" func ClearBackground(color: Color) +export extern "BeginDrawing" func BeginDrawing() +export extern "EndDrawing" func EndDrawing() +export extern "BeginMode2D" func BeginMode2D(camera: Camera2D) +export extern "EndMode2D" func EndMode2D() +export extern "BeginMode3D" func BeginMode3D(camera: Camera3D) +export extern "EndMode3D" func EndMode3D() +export extern "BeginTextureMode" func BeginTextureMode(target: RenderTexture2D) +export extern "EndTextureMode" func EndTextureMode() +export extern "BeginShaderMode" func BeginShaderMode(shader: Shader) +export extern "EndShaderMode" func EndShaderMode() +export extern "BeginBlendMode" func BeginBlendMode(mode: i32) +export extern "EndBlendMode" func EndBlendMode() +export extern "BeginScissorMode" func BeginScissorMode(x: i32, y: i32, width: i32, height: i32) +export extern "EndScissorMode" func EndScissorMode() +// export extern "BeginVrStereoMode" func BeginVrStereoMode(config: VrStereoConfig) +// export extern "EndVrStereoMode" func EndVrStereoMode() + +// export extern "LoadVrStereoConfig" func LoadVrStereoConfig(device: VrDeviceInfo): VrStereoConfig +// export extern "UnloadVrStereoConfig" func UnloadVrStereoConfig(config: VrStereoConfig) + +export extern "LoadShader" func LoadShader(vsFileName: cstring, fsFileName: cstring): Shader +export extern "LoadShaderFromMemory" func LoadShaderFromMemory(vsCode: cstring, fsCode: cstring): Shader +export extern "IsShaderValid" func IsShaderValid(shader: Shader): bool +export extern "GetShaderLocation" func GetShaderLocation(shader: Shader, uniformName: cstring): i32 +export extern "GetShaderLocationAttrib" func GetShaderLocationAttrib(shader: Shader, attribName: cstring): i32 +export extern "SetShaderValue" func SetShaderValue(shader: Shader, locIndex: i32, value: ^void, uniformType: i32) +export extern "SetShaderValueV" func SetShaderValueV(shader: Shader, locIndex: i32, value: ^void, uniformType: i32, count: i32) +export extern "SetShaderValueMatrix" func SetShaderValueMatrix(shader: Shader, locIndex: i32, mat: Matrix) +export extern "SetShaderValueTexture" func SetShaderValueTexture(shader: Shader, locIndex: i32, texture: Texture2D) +export extern "UnloadShader" func UnloadShader(shader: Shader) + +export extern "GetScreenToWorldRay" func GetScreenToWorldRay(position: Vector2, camera: Camera): Ray +export extern "GetScreenToWorldRayEx" func GetScreenToWorldRayEx(position: Vector2, camera: Camera, width: i32, height: i32): Ray +export extern "GetWorldToScreen" func GetWorldToScreen(position: Vector3, camera: Camera): Vector2 +export extern "GetWorldToScreenEx" func GetWorldToScreenEx(position: Vector3, camera: Camera, width: i32, height: i32): Vector2 +export extern "GetWorldToScreen2D" func GetWorldToScreen2D(position: Vector2, camera: Camera2D): Vector2 +export extern "GetScreenToWorld2D" func GetScreenToWorld2D(position: Vector2, camera: Camera2D): Vector2 +export extern "GetCameraMatrix" func GetCameraMatrix(camera: Camera): Matrix +export extern "GetCameraMatrix2D" func GetCameraMatrix2D(camera: Camera2D): Matrix + +export extern "SetTargetFPS" func SetTargetFPS(fps: i32) +export extern "GetFrameTime" func GetFrameTime(): f32 +export extern "GetTime" func GetTime(): f64 +export extern "GetFPS" func GetFPS(): i32 + +export extern "SwapScreenBuffer" func SwapScreenBuffer() +export extern "PollInputEvents" func PollInputEvents() +export extern "WaitTime" func WaitTime(seconds: f64) + +export extern "SetRandomSeed" func SetRandomSeed(seed: u32) +export extern "GetRandomValue" func GetRandomValue(min: i32, max: i32): i32 +export extern "LoadRandomSequence" func LoadRandomSequence(count: u32, min: i32, max: i32): ^i32 +export extern "UnloadRandomSequence" func UnloadRandomSequence(sequence: ^i32) + +export extern "TakeScreenshot" func TakeScreenshot(fileName: cstring) +export extern "SetConfigFlags" func SetConfigFlags(flags: u32) +export extern "OpenURL" func OpenURL(url: cstring) + +// todo(nub31): not implemented +// // NOTE: Following functions implemented in module [utils] +// //------------------------------------------------------------------ +// RLAPI void TraceLog(int logLevel, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +// RLAPI void SetTraceLogLevel(int logLevel); // Set the current threshold (minimum) log level +// RLAPI void *MemAlloc(unsigned int size); // Internal memory allocator +// RLAPI void *MemRealloc(void *ptr, unsigned int size); // Internal memory reallocator +// RLAPI void MemFree(void *ptr); // Internal memory free + +// // Set custom callbacks +// // WARNING: Callbacks setup is intended for advanced users +// RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set custom trace log +// RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader +// RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver +// RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader +// RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver + +// // Files management functions +// RLAPI unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read) +// RLAPI void UnloadFileData(unsigned char *data); // Unload file data allocated by LoadFileData() +// RLAPI bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success +// RLAPI bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success +// RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string +// RLAPI void UnloadFileText(char *text); // Unload file text data allocated by LoadFileText() +// RLAPI bool SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated, returns true on success +// //------------------------------------------------------------------ + +// // File system functions +// RLAPI bool FileExists(const char *fileName); // Check if file exists +// RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists +// RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav) +// RLAPI int GetFileLength(const char *fileName); // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h) +// RLAPI const char *GetFileExtension(const char *fileName); // Get pointer to extension for a filename string (includes dot: '.png') +// RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string +// RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string) +// RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string) +// RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string) +// RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string) +// RLAPI const char *GetApplicationDirectory(void); // Get the directory of the running application (uses static string) +// RLAPI int MakeDirectory(const char *dirPath); // Create directories (including full path requested), returns 0 on success +// RLAPI bool ChangeDirectory(const char *dir); // Change working directory, return true on success +// RLAPI bool IsPathFile(const char *path); // Check if a given path is a file or a directory +// RLAPI bool IsFileNameValid(const char *fileName); // Check if fileName is valid for the platform/OS +// RLAPI FilePathList LoadDirectoryFiles(const char *dirPath); // Load directory filepaths +// RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan. Use 'DIR' in the filter string to include directories in the result +// RLAPI void UnloadDirectoryFiles(FilePathList files); // Unload filepaths +// RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window +// RLAPI FilePathList LoadDroppedFiles(void); // Load dropped filepaths +// RLAPI void UnloadDroppedFiles(FilePathList files); // Unload dropped filepaths +// RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time) + +// // Compression/Encoding functionality +// RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize); // Compress data (DEFLATE algorithm), memory must be MemFree() +// RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize); // Decompress data (DEFLATE algorithm), memory must be MemFree() +// RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize); // Encode data to Base64 string, memory must be MemFree() +// RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize); // Decode Base64 string data, memory must be MemFree() +// RLAPI unsigned int ComputeCRC32(unsigned char *data, int dataSize); // Compute CRC32 hash code +// RLAPI unsigned int *ComputeMD5(unsigned char *data, int dataSize); // Compute MD5 hash code, returns static int[4] (16 bytes) +// RLAPI unsigned int *ComputeSHA1(unsigned char *data, int dataSize); // Compute SHA1 hash code, returns static int[5] (20 bytes) + + +// // Automation events functionality +// RLAPI AutomationEventList LoadAutomationEventList(const char *fileName); // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS +// RLAPI void UnloadAutomationEventList(AutomationEventList list); // Unload automation events list from file +// RLAPI bool ExportAutomationEventList(AutomationEventList list, const char *fileName); // Export automation events list as text file +// RLAPI void SetAutomationEventList(AutomationEventList *list); // Set automation event list to record to +// RLAPI void SetAutomationEventBaseFrame(int frame); // Set automation event internal base frame to start recording +// RLAPI void StartAutomationEventRecording(void); // Start recording automation events (AutomationEventList must be set) +// RLAPI void StopAutomationEventRecording(void); // Stop recording automation events +// RLAPI void PlayAutomationEvent(AutomationEvent event); // Play a recorded automation event + +// //------------------------------------------------------------------------------------ +// // Input Handling Functions (Module: core) +// //------------------------------------------------------------------------------------ + +// // Input-related functions: keyboard +// RLAPI bool IsKeyPressed(int key); // Check if a key has been pressed once +// RLAPI bool IsKeyPressedRepeat(int key); // Check if a key has been pressed again +// RLAPI bool IsKeyDown(int key); // Check if a key is being pressed +// RLAPI bool IsKeyReleased(int key); // Check if a key has been released once +// RLAPI bool IsKeyUp(int key); // Check if a key is NOT being pressed +// RLAPI int GetKeyPressed(void); // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty +// RLAPI int GetCharPressed(void); // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty +// RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC) + +// // Input-related functions: gamepads +// RLAPI bool IsGamepadAvailable(int gamepad); // Check if a gamepad is available +// RLAPI const char *GetGamepadName(int gamepad); // Get gamepad internal name id +// RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Check if a gamepad button has been pressed once +// RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Check if a gamepad button is being pressed +// RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Check if a gamepad button has been released once +// RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Check if a gamepad button is NOT being pressed +// RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed +// RLAPI int GetGamepadAxisCount(int gamepad); // Get gamepad axis count for a gamepad +// RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Get axis movement value for a gamepad axis +// RLAPI int SetGamepadMappings(const char *mappings); // Set internal gamepad mappings (SDL_GameControllerDB) +// RLAPI void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration); // Set gamepad vibration for both motors (duration in seconds) + +// // Input-related functions: mouse +// RLAPI bool IsMouseButtonPressed(int button); // Check if a mouse button has been pressed once +// RLAPI bool IsMouseButtonDown(int button); // Check if a mouse button is being pressed +// RLAPI bool IsMouseButtonReleased(int button); // Check if a mouse button has been released once +// RLAPI bool IsMouseButtonUp(int button); // Check if a mouse button is NOT being pressed +// RLAPI int GetMouseX(void); // Get mouse position X +// RLAPI int GetMouseY(void); // Get mouse position Y +// RLAPI Vector2 GetMousePosition(void); // Get mouse position XY +// RLAPI Vector2 GetMouseDelta(void); // Get mouse delta between frames +// RLAPI void SetMousePosition(int x, int y); // Set mouse position XY +// RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset +// RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling +// RLAPI float GetMouseWheelMove(void); // Get mouse wheel movement for X or Y, whichever is larger +// RLAPI Vector2 GetMouseWheelMoveV(void); // Get mouse wheel movement for both X and Y +// RLAPI void SetMouseCursor(int cursor); // Set mouse cursor + +// // Input-related functions: touch +// RLAPI int GetTouchX(void); // Get touch position X for touch point 0 (relative to screen size) +// RLAPI int GetTouchY(void); // Get touch position Y for touch point 0 (relative to screen size) +// RLAPI Vector2 GetTouchPosition(int index); // Get touch position XY for a touch point index (relative to screen size) +// RLAPI int GetTouchPointId(int index); // Get touch point identifier for given index +// RLAPI int GetTouchPointCount(void); // Get number of touch points + +// //------------------------------------------------------------------------------------ +// // Gestures and Touch Handling Functions (Module: rgestures) +// //------------------------------------------------------------------------------------ +// RLAPI void SetGesturesEnabled(unsigned int flags); // Enable a set of gestures using flags +// RLAPI bool IsGestureDetected(unsigned int gesture); // Check if a gesture have been detected +// RLAPI int GetGestureDetected(void); // Get latest detected gesture +// RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in seconds +// RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector +// RLAPI float GetGestureDragAngle(void); // Get gesture drag angle +// RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta +// RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle + +// //------------------------------------------------------------------------------------ +// // Camera System Functions (Module: rcamera) +// //------------------------------------------------------------------------------------ +// RLAPI void UpdateCamera(Camera *camera, int mode); // Update camera position for selected mode +// RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation + +// //------------------------------------------------------------------------------------ +// // Basic Shapes Drawing Functions (Module: shapes) +// //------------------------------------------------------------------------------------ +// // Set texture and rectangle to be used on shapes drawing +// // NOTE: It can be useful when using basic shapes and one single font, +// // defining a font char white rectangle would allow drawing everything in a single draw call +// RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Set texture and rectangle to be used on shapes drawing +// RLAPI Texture2D GetShapesTexture(void); // Get texture that is used for shapes drawing +// RLAPI Rectangle GetShapesTextureRectangle(void); // Get texture source rectangle that is used for shapes drawing + +// // Basic shapes drawing functions +// RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel using geometry [Can be slow, use with care] +// RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel using geometry (Vector version) [Can be slow, use with care] +// RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line +// RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (using gl lines) +// RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line (using triangles/quads) +// RLAPI void DrawLineStrip(const Vector2 *points, int pointCount, Color color); // Draw lines sequence (using gl lines) +// RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw line segment cubic-bezier in-out interpolation +// RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle +// RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw a piece of a circle +// RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline +// RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color inner, Color outer); // Draw a gradient-filled circle +// RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version) +// RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline +// RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color); // Draw circle outline (Vector version) +// RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse +// RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline +// RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring +// RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring outline +// RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle +// RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version) +// RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle +// RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters +// RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color top, Color bottom); // Draw a vertical-gradient-filled rectangle +// RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color left, Color right); // Draw a horizontal-gradient-filled rectangle +// RLAPI void DrawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight); // Draw a gradient-filled rectangle with custom vertex colors +// RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline +// RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color); // Draw rectangle outline with extended parameters +// RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges +// RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle lines with rounded edges +// RLAPI void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline +// RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +// RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!) +// RLAPI void DrawTriangleFan(const Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points (first vertex is the center) +// RLAPI void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points +// RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version) +// RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides +// RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters + +// // Splines drawing functions +// RLAPI void DrawSplineLinear(const Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Linear, minimum 2 points +// RLAPI void DrawSplineBasis(const Vector2 *points, int pointCount, float thick, Color color); // Draw spline: B-Spline, minimum 4 points +// RLAPI void DrawSplineCatmullRom(const Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Catmull-Rom, minimum 4 points +// RLAPI void DrawSplineBezierQuadratic(const Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...] +// RLAPI void DrawSplineBezierCubic(const Vector2 *points, int pointCount, float thick, Color color); // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...] +// RLAPI void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color); // Draw spline segment: Linear, 2 points +// RLAPI void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points +// RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points +// RLAPI void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point +// RLAPI void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points + +// // Spline segment point evaluation functions, for a given t [0.0f .. 1.0f] +// RLAPI Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t); // Get (evaluate) spline point: Linear +// RLAPI Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: B-Spline +// RLAPI Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t); // Get (evaluate) spline point: Catmull-Rom +// RLAPI Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t); // Get (evaluate) spline point: Quadratic Bezier +// RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t); // Get (evaluate) spline point: Cubic Bezier + +// // Basic shapes collision detection functions +// RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles +// RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles +// RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle +// RLAPI bool CheckCollisionCircleLine(Vector2 center, float radius, Vector2 p1, Vector2 p2); // Check if circle collides with a line created betweeen two points [p1] and [p2] +// RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle +// RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle +// RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle +// RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold); // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold] +// RLAPI bool CheckCollisionPointPoly(Vector2 point, const Vector2 *points, int pointCount); // Check if point is within a polygon described by array of vertices +// RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference +// RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision + +// //------------------------------------------------------------------------------------ +// // Texture Loading and Drawing Functions (Module: textures) +// //------------------------------------------------------------------------------------ + +// // Image loading functions +// // NOTE: These functions do not require GPU access +// RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM) +// RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data +// RLAPI Image LoadImageAnim(const char *fileName, int *frames); // Load image sequence from file (frames appended to image.data) +// RLAPI Image LoadImageAnimFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int *frames); // Load image sequence from memory buffer +// RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load image from memory buffer, fileType refers to extension: i.e. '.png' +// RLAPI Image LoadImageFromTexture(Texture2D texture); // Load image from GPU texture data +// RLAPI Image LoadImageFromScreen(void); // Load image from screen buffer and (screenshot) +// RLAPI bool IsImageValid(Image image); // Check if an image is valid (data and parameters) +// RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM) +// RLAPI bool ExportImage(Image image, const char *fileName); // Export image data to file, returns true on success +// RLAPI unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize); // Export image to memory buffer +// RLAPI bool ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes, returns true on success + +// // Image generation functions +// RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color +// RLAPI Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end); // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient +// RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient +// RLAPI Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer); // Generate image: square gradient +// RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked +// RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise +// RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise +// RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm, bigger tileSize means bigger cells +// RLAPI Image GenImageText(int width, int height, const char *text); // Generate image: grayscale image from text data + +// // Image manipulation functions +// RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) +// RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece +// RLAPI Image ImageFromChannel(Image image, int selectedChannel); // Create an image from a selected channel of another image (GRAYSCALE) +// RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) +// RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font) +// RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format +// RLAPI void ImageToPOT(Image *image, Color fill); // Convert image to POT (power-of-two) +// RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle +// RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value +// RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color +// RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image +// RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel +// RLAPI void ImageBlurGaussian(Image *image, int blurSize); // Apply Gaussian blur using a box blur approximation +// RLAPI void ImageKernelConvolution(Image *image, const float *kernel, int kernelSize); // Apply custom square convolution kernel to image +// RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm) +// RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm) +// RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color +// RLAPI void ImageMipmaps(Image *image); // Compute all mipmap levels for a provided image +// RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +// RLAPI void ImageFlipVertical(Image *image); // Flip image vertically +// RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally +// RLAPI void ImageRotate(Image *image, int degrees); // Rotate image by input angle in degrees (-359 to 359) +// RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg +// RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg +// RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint +// RLAPI void ImageColorInvert(Image *image); // Modify image color: invert +// RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale +// RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) +// RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) +// RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color +// RLAPI Color *LoadImageColors(Image image); // Load color data from image as a Color array (RGBA - 32bit) +// RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount); // Load colors palette from image as a Color array (RGBA - 32bit) +// RLAPI void UnloadImageColors(Color *colors); // Unload color data loaded with LoadImageColors() +// RLAPI void UnloadImagePalette(Color *colors); // Unload colors palette loaded with LoadImagePalette() +// RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle +// RLAPI Color GetImageColor(Image image, int x, int y); // Get image pixel color at (x, y) position + +// // Image drawing functions +// // NOTE: Image software-rendering functions (CPU) +// RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color +// RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image +// RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version) +// RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image +// RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version) +// RLAPI void ImageDrawLineEx(Image *dst, Vector2 start, Vector2 end, int thick, Color color); // Draw a line defining thickness within an image +// RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw a filled circle within an image +// RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw a filled circle within an image (Vector version) +// RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle outline within an image +// RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color); // Draw circle outline within an image (Vector version) +// RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image +// RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version) +// RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image +// RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image +// RLAPI void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle within an image +// RLAPI void ImageDrawTriangleEx(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3); // Draw triangle with interpolated colors within an image +// RLAPI void ImageDrawTriangleLines(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline within an image +// RLAPI void ImageDrawTriangleFan(Image *dst, Vector2 *points, int pointCount, Color color); // Draw a triangle fan defined by points within an image (first vertex is the center) +// RLAPI void ImageDrawTriangleStrip(Image *dst, Vector2 *points, int pointCount, Color color); // Draw a triangle strip defined by points within an image +// RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source) +// RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) within an image (destination) +// RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination) + +// // Texture loading functions +// // NOTE: These functions require GPU access +// RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM) +// RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data +// RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout); // Load cubemap from image, multiple image cubemap layouts supported +// RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer) +// RLAPI bool IsTextureValid(Texture2D texture); // Check if a texture is valid (loaded in GPU) +// RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM) +// RLAPI bool IsRenderTextureValid(RenderTexture2D target); // Check if a render texture is valid (loaded in GPU) +// RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM) +// RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data +// RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels); // Update GPU texture rectangle with new data + +// // Texture configuration functions +// RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture +// RLAPI void SetTextureFilter(Texture2D texture, int filter); // Set texture scaling filter mode +// RLAPI void SetTextureWrap(Texture2D texture, int wrap); // Set texture wrapping mode + +// // Texture drawing functions +// RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D +// RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2 +// RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters +// RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle +// RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters +// RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely + +// // Color/pixel related functions +// RLAPI bool ColorIsEqual(Color col1, Color col2); // Check if two colors are equal +// RLAPI Color Fade(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +// RLAPI int ColorToInt(Color color); // Get hexadecimal value for a Color (0xRRGGBBAA) +// RLAPI Vector4 ColorNormalize(Color color); // Get Color normalized as float [0..1] +// RLAPI Color ColorFromNormalized(Vector4 normalized); // Get Color from normalized values [0..1] +// RLAPI Vector3 ColorToHSV(Color color); // Get HSV values for a Color, hue [0..360], saturation/value [0..1] +// RLAPI Color ColorFromHSV(float hue, float saturation, float value); // Get a Color from HSV values, hue [0..360], saturation/value [0..1] +// RLAPI Color ColorTint(Color color, Color tint); // Get color multiplied with another color +// RLAPI Color ColorBrightness(Color color, float factor); // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f +// RLAPI Color ColorContrast(Color color, float contrast); // Get color with contrast correction, contrast values between -1.0f and 1.0f +// RLAPI Color ColorAlpha(Color color, float alpha); // Get color with alpha applied, alpha goes from 0.0f to 1.0f +// RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint); // Get src alpha-blended into dst color with tint +// RLAPI Color ColorLerp(Color color1, Color color2, float factor); // Get color lerp interpolation between two colors, factor [0.0f..1.0f] +// RLAPI Color GetColor(unsigned int hexValue); // Get Color structure from hexadecimal value +// RLAPI Color GetPixelColor(void *srcPtr, int format); // Get Color from a source pixel pointer of certain format +// RLAPI void SetPixelColor(void *dstPtr, Color color, int format); // Set color formatted into destination pixel pointer +// RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes for certain format + +// //------------------------------------------------------------------------------------ +// // Font Loading and Text Drawing Functions (Module: text) +// //------------------------------------------------------------------------------------ + +// // Font loading/unloading functions +// RLAPI Font GetFontDefault(void); // Get the default Font +// RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM) +// RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height +// RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style) +// RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +// RLAPI bool IsFontValid(Font font); // Check if a font is valid (font data loaded, WARNING: GPU texture not checked) +// RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use +// RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info +// RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount); // Unload font chars info data (RAM) +// RLAPI void UnloadFont(Font font); // Unload font from GPU memory (VRAM) +// RLAPI bool ExportFontAsCode(Font font, const char *fileName); // Export font as code file, returns true on success + +// // Text drawing functions +// RLAPI void DrawFPS(int posX, int posY); // Draw current FPS +// RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font) +// RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters +// RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation) +// RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint) +// RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint) + +// // Text font info functions +// RLAPI void SetTextLineSpacing(int spacing); // Set vertical line spacing when drawing with line-breaks +// RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font +// RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font +// RLAPI int GetGlyphIndex(Font font, int codepoint); // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found +// RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint); // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found +// RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint); // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found + +// // Text codepoints management functions (unicode characters) +// RLAPI char *LoadUTF8(const int *codepoints, int length); // Load UTF-8 text encoded from codepoints array +// RLAPI void UnloadUTF8(char *text); // Unload UTF-8 text encoded from codepoints array +// RLAPI int *LoadCodepoints(const char *text, int *count); // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter +// RLAPI void UnloadCodepoints(int *codepoints); // Unload codepoints data from memory +// RLAPI int GetCodepointCount(const char *text); // Get total number of codepoints in a UTF-8 encoded string +// RLAPI int GetCodepoint(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +// RLAPI int GetCodepointNext(const char *text, int *codepointSize); // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +// RLAPI int GetCodepointPrevious(const char *text, int *codepointSize); // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure +// RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size); // Encode one codepoint into UTF-8 byte array (array length returned as parameter) + +// // Text strings management functions (no UTF-8 strings, only byte chars) +// // NOTE: Some strings allocate memory internally for returned strings, just be careful! +// RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied +// RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal +// RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending +// RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf() style) +// RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string +// RLAPI char *TextReplace(const char *text, const char *replace, const char *by); // Replace text string (WARNING: memory must be freed!) +// RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (WARNING: memory must be freed!) +// RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter +// RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings +// RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor! +// RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string +// RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string +// RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string +// RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string +// RLAPI const char *TextToSnake(const char *text); // Get Snake case notation version of provided string +// RLAPI const char *TextToCamel(const char *text); // Get Camel case notation version of provided string + +// RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported) +// RLAPI float TextToFloat(const char *text); // Get float value from text (negative values not supported) + +// //------------------------------------------------------------------------------------ +// // Basic 3d Shapes Drawing Functions (Module: models) +// //------------------------------------------------------------------------------------ + +// // Basic geometric 3D shapes drawing functions +// RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +// RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line +// RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space +// RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!) +// RLAPI void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color); // Draw a triangle strip defined by points +// RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube +// RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) +// RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires +// RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version) +// RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere +// RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters +// RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires +// RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone +// RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos +// RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires +// RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos +// RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos +// RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos +// RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ +// RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line +// RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) + +// //------------------------------------------------------------------------------------ +// // Model 3d Loading and Drawing Functions (Module: models) +// //------------------------------------------------------------------------------------ + +// // Model management functions +// RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials) +// RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material) +// RLAPI bool IsModelValid(Model model); // Check if a model is valid (loaded in GPU, VAO/VBOs) +// RLAPI void UnloadModel(Model model); // Unload model (including meshes) from memory (RAM and/or VRAM) +// RLAPI BoundingBox GetModelBoundingBox(Model model); // Compute model bounding box limits (considers all meshes) + +// // Model drawing functions +// RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set) +// RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters +// RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set) +// RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters +// RLAPI void DrawModelPoints(Model model, Vector3 position, float scale, Color tint); // Draw a model as points +// RLAPI void DrawModelPointsEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model as points with extended parameters +// RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires) +// RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint); // Draw a billboard texture +// RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source +// RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation + +// // Mesh management functions +// RLAPI void UploadMesh(Mesh *mesh, bool dynamic); // Upload mesh vertex data in GPU and provide VAO/VBO ids +// RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index +// RLAPI void UnloadMesh(Mesh mesh); // Unload mesh data from CPU and GPU +// RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform); // Draw a 3d mesh with material and transform +// RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms +// RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits +// RLAPI void GenMeshTangents(Mesh *mesh); // Compute mesh tangents +// RLAPI bool ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file, returns true on success +// RLAPI bool ExportMeshAsCode(Mesh mesh, const char *fileName); // Export mesh as code file (.h) defining multiple arrays of vertex attributes + +// // Mesh generation functions +// RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh +// RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions) +// RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh +// RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere) +// RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap) +// RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh +// RLAPI Mesh GenMeshCone(float radius, float height, int slices); // Generate cone/pyramid mesh +// RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh +// RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh +// RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data +// RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data + +// // Material loading/unloading functions +// RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file +// RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +// RLAPI bool IsMaterialValid(Material material); // Check if a material is valid (shader assigned, map textures loaded in GPU) +// RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM) +// RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) +// RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh + +// // Model animations loading/unloading functions +// RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount); // Load model animations from file +// RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose (CPU) +// RLAPI void UpdateModelAnimationBones(Model model, ModelAnimation anim, int frame); // Update model animation mesh bone matrices (GPU skinning) +// RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data +// RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount); // Unload animation array data +// RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match + +// // Collision detection functions +// RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2); // Check collision between two spheres +// RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Check collision between two bounding boxes +// RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Check collision between box and sphere +// RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius); // Get collision info between ray and sphere +// RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box); // Get collision info between ray and box +// RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform); // Get collision info between ray and mesh +// RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle +// RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4); // Get collision info between ray and quad + +// //------------------------------------------------------------------------------------ +// // Audio Loading and Playing Functions (Module: audio) +// //------------------------------------------------------------------------------------ +// typedef void (*AudioCallback)(void *bufferData, unsigned int frames); + +// // Audio device management functions +// RLAPI void InitAudioDevice(void); // Initialize audio device and context +// RLAPI void CloseAudioDevice(void); // Close the audio device and context +// RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully +// RLAPI void SetMasterVolume(float volume); // Set master volume (listener) +// RLAPI float GetMasterVolume(void); // Get master volume (listener) + +// // Wave/Sound loading/unloading functions +// RLAPI Wave LoadWave(const char *fileName); // Load wave data from file +// RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +// RLAPI bool IsWaveValid(Wave wave); // Checks if wave data is valid (data loaded and parameters) +// RLAPI Sound LoadSound(const char *fileName); // Load sound from file +// RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data +// RLAPI Sound LoadSoundAlias(Sound source); // Create a new sound that shares the same sample data as the source sound, does not own the sound data +// RLAPI bool IsSoundValid(Sound sound); // Checks if a sound is valid (data loaded and buffers initialized) +// RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data +// RLAPI void UnloadWave(Wave wave); // Unload wave data +// RLAPI void UnloadSound(Sound sound); // Unload sound +// RLAPI void UnloadSoundAlias(Sound alias); // Unload a sound alias (does not deallocate sample data) +// RLAPI bool ExportWave(Wave wave, const char *fileName); // Export wave data to file, returns true on success +// RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h), returns true on success + +// // Wave/Sound management functions +// RLAPI void PlaySound(Sound sound); // Play a sound +// RLAPI void StopSound(Sound sound); // Stop playing a sound +// RLAPI void PauseSound(Sound sound); // Pause a sound +// RLAPI void ResumeSound(Sound sound); // Resume a paused sound +// RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing +// RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level) +// RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level) +// RLAPI void SetSoundPan(Sound sound, float pan); // Set pan for a sound (0.5 is center) +// RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave +// RLAPI void WaveCrop(Wave *wave, int initFrame, int finalFrame); // Crop a wave to defined frames range +// RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format +// RLAPI float *LoadWaveSamples(Wave wave); // Load samples data from wave as a 32bit float data array +// RLAPI void UnloadWaveSamples(float *samples); // Unload samples data loaded with LoadWaveSamples() + +// // Music management functions +// RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file +// RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data +// RLAPI bool IsMusicValid(Music music); // Checks if a music stream is valid (context and buffers initialized) +// RLAPI void UnloadMusicStream(Music music); // Unload music stream +// RLAPI void PlayMusicStream(Music music); // Start music playing +// RLAPI bool IsMusicStreamPlaying(Music music); // Check if music is playing +// RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming +// RLAPI void StopMusicStream(Music music); // Stop music playing +// RLAPI void PauseMusicStream(Music music); // Pause music playing +// RLAPI void ResumeMusicStream(Music music); // Resume playing paused music +// RLAPI void SeekMusicStream(Music music, float position); // Seek music to a position (in seconds) +// RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level) +// RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level) +// RLAPI void SetMusicPan(Music music, float pan); // Set pan for a music (0.5 is center) +// RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) +// RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) + +// // AudioStream management functions +// RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data) +// RLAPI bool IsAudioStreamValid(AudioStream stream); // Checks if an audio stream is valid (buffers initialized) +// RLAPI void UnloadAudioStream(AudioStream stream); // Unload audio stream and free memory +// RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data +// RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill +// RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream +// RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream +// RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream +// RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing +// RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream +// RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level) +// RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level) +// RLAPI void SetAudioStreamPan(AudioStream stream, float pan); // Set pan for audio stream (0.5 is centered) +// RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams +// RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data + +// RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as 'float' +// RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream + +// RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as 'float' +// RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline diff --git a/example/src/ref.nub b/example/src/ref.nub deleted file mode 100644 index 5bfe824..0000000 --- a/example/src/ref.nub +++ /dev/null @@ -1,40 +0,0 @@ -module "core" - -extern "puts" func puts(text: cstring) -extern "malloc" func malloc(size: u64): ^void -extern "free" func free(address: ^void) - -export struct ref -{ - value: ^T - count: ^u64 - - @oncreate - func on_create() - { - puts("on_create") - this.value = @interpret(^T, malloc(@size(T))) - this.count = @interpret(^u64, malloc(@size(u64))) - this.count^ = 1 - } - - @oncopy - func on_copy() - { - puts("on_copy") - this.count^ = this.count^ + 1 - } - - @ondestroy - func on_destroy() - { - puts("on_destroy") - this.count^ = this.count^ - 1 - if this.count^ <= 0 - { - puts("free") - free(@interpret(^void, this.value)) - free(@interpret(^void, this.count)) - } - } -} \ No newline at end of file