From 1e2e7840af5b5cdd538fbd8e4ea2b75d696a3738 Mon Sep 17 00:00:00 2001 From: Wesley Kerfoot Date: Tue, 5 Oct 2021 10:28:43 -0400 Subject: [PATCH] initial commit --- compile_raygui.sh | 1 + lsystem.nimble | 13 + raygui.so | Bin 0 -> 14960 bytes src/lsystem.nim | 202 +++++ src/lsystempkg/raygui.nim | 354 +++++++++ src/lsystempkg/raylib.nim | 1291 +++++++++++++++++++++++++++++++ src/lsystempkg/raymath.nim | 270 +++++++ src/lsystempkg/rlgl.nim | 318 ++++++++ styles/README.md | 36 + styles/ashes/README.md | 16 + styles/ashes/ashes.rgs | 24 + styles/ashes/font_readme.txt | 51 ++ styles/ashes/screenshot.png | Bin 0 -> 42971 bytes styles/ashes/style_table.png | Bin 0 -> 23740 bytes styles/ashes/v5loxical.ttf | Bin 0 -> 26384 bytes styles/bluish/README.md | 16 + styles/bluish/bluish.rgs | 24 + styles/bluish/font_readme.txt | 76 ++ styles/bluish/homespun.ttf | Bin 0 -> 16040 bytes styles/bluish/screenshot.png | Bin 0 -> 55917 bytes styles/bluish/style_table.png | Bin 0 -> 27222 bytes styles/candy/README.md | 16 + styles/candy/candy.rgs | 24 + styles/candy/font_readme.txt | 27 + styles/candy/screenshot.png | Bin 0 -> 60853 bytes styles/candy/style_table.png | Bin 0 -> 24796 bytes styles/candy/v5easter.ttf | Bin 0 -> 27140 bytes styles/cherry/README.md | 16 + styles/cherry/Westington.ttf | Bin 0 -> 49360 bytes styles/cherry/cherry.rgs | 24 + styles/cherry/screenshot.png | Bin 0 -> 66058 bytes styles/cherry/style_table.png | Bin 0 -> 27315 bytes styles/cyber/Kyrou 7 Wide.ttf | Bin 0 -> 85240 bytes styles/cyber/README.md | 16 + styles/cyber/cyber.rgs | 24 + styles/cyber/font_readme.txt | 36 + styles/cyber/screenshot.png | Bin 0 -> 55540 bytes styles/cyber/style_table.png | Bin 0 -> 25413 bytes styles/default/README.md | 14 + styles/default/default.rgs | 69 ++ styles/default/screenshot.png | Bin 0 -> 55326 bytes styles/default/style_table.png | Bin 0 -> 23916 bytes styles/jungle/Pixel Intv.otf | Bin 0 -> 19892 bytes styles/jungle/README.md | 16 + styles/jungle/font_readme.txt | 47 ++ styles/jungle/jungle.rgs | 24 + styles/jungle/screenshot.png | Bin 0 -> 54542 bytes styles/jungle/style_table.png | Bin 0 -> 24692 bytes styles/lavanda/Cartridge.ttf | Bin 0 -> 44576 bytes styles/lavanda/README.md | 16 + styles/lavanda/font_readme.txt | 6 + styles/lavanda/lavanda.rgs | 24 + styles/lavanda/screenshot.png | Bin 0 -> 66412 bytes styles/lavanda/style_table.png | Bin 0 -> 26517 bytes styles/terminal/Mecha.ttf | Bin 0 -> 105740 bytes styles/terminal/README.md | 16 + styles/terminal/screenshot.png | Bin 0 -> 50850 bytes styles/terminal/style_table.png | Bin 0 -> 23465 bytes styles/terminal/terminal.rgs | 24 + 59 files changed, 3131 insertions(+) create mode 100755 compile_raygui.sh create mode 100644 lsystem.nimble create mode 100755 raygui.so create mode 100644 src/lsystem.nim create mode 100644 src/lsystempkg/raygui.nim create mode 100644 src/lsystempkg/raylib.nim create mode 100644 src/lsystempkg/raymath.nim create mode 100644 src/lsystempkg/rlgl.nim create mode 100644 styles/README.md create mode 100644 styles/ashes/README.md create mode 100644 styles/ashes/ashes.rgs create mode 100644 styles/ashes/font_readme.txt create mode 100644 styles/ashes/screenshot.png create mode 100644 styles/ashes/style_table.png create mode 100644 styles/ashes/v5loxical.ttf create mode 100644 styles/bluish/README.md create mode 100644 styles/bluish/bluish.rgs create mode 100644 styles/bluish/font_readme.txt create mode 100644 styles/bluish/homespun.ttf create mode 100644 styles/bluish/screenshot.png create mode 100644 styles/bluish/style_table.png create mode 100644 styles/candy/README.md create mode 100644 styles/candy/candy.rgs create mode 100644 styles/candy/font_readme.txt create mode 100644 styles/candy/screenshot.png create mode 100644 styles/candy/style_table.png create mode 100644 styles/candy/v5easter.ttf create mode 100644 styles/cherry/README.md create mode 100644 styles/cherry/Westington.ttf create mode 100644 styles/cherry/cherry.rgs create mode 100644 styles/cherry/screenshot.png create mode 100644 styles/cherry/style_table.png create mode 100644 styles/cyber/Kyrou 7 Wide.ttf create mode 100644 styles/cyber/README.md create mode 100644 styles/cyber/cyber.rgs create mode 100644 styles/cyber/font_readme.txt create mode 100644 styles/cyber/screenshot.png create mode 100644 styles/cyber/style_table.png create mode 100644 styles/default/README.md create mode 100644 styles/default/default.rgs create mode 100644 styles/default/screenshot.png create mode 100644 styles/default/style_table.png create mode 100644 styles/jungle/Pixel Intv.otf create mode 100644 styles/jungle/README.md create mode 100644 styles/jungle/font_readme.txt create mode 100644 styles/jungle/jungle.rgs create mode 100644 styles/jungle/screenshot.png create mode 100644 styles/jungle/style_table.png create mode 100644 styles/lavanda/Cartridge.ttf create mode 100644 styles/lavanda/README.md create mode 100644 styles/lavanda/font_readme.txt create mode 100644 styles/lavanda/lavanda.rgs create mode 100644 styles/lavanda/screenshot.png create mode 100644 styles/lavanda/style_table.png create mode 100644 styles/terminal/Mecha.ttf create mode 100644 styles/terminal/README.md create mode 100644 styles/terminal/screenshot.png create mode 100644 styles/terminal/style_table.png create mode 100644 styles/terminal/terminal.rgs diff --git a/compile_raygui.sh b/compile_raygui.sh new file mode 100755 index 0000000..d2b7b84 --- /dev/null +++ b/compile_raygui.sh @@ -0,0 +1 @@ +gcc -shared -fPIC -DRAYGUIDEF -DRAYGUI_IMPLEMENTATION -lraylib -lGL -lm -lpthread -ldl -lrt -lX11 raygui.h -o raygui.so diff --git a/lsystem.nimble b/lsystem.nimble new file mode 100644 index 0000000..513f5e6 --- /dev/null +++ b/lsystem.nimble @@ -0,0 +1,13 @@ +# Package + +version = "0.1.0" +author = "Wesley Kerfoot" +description = "A new awesome nimble package" +license = "MIT" +srcDir = "src" +bin = @["lsystem"] + + +# Dependencies + +requires "nim >= 1.4.8" diff --git a/raygui.so b/raygui.so new file mode 100755 index 0000000000000000000000000000000000000000..71f39d4f2d6342759a85086b531d3fe65e32cc73 GIT binary patch literal 14960 zcmeHOU2GIp6uw)i76gk3TJfhN@j)Vtw1A>XWlL$h!~zN>k)XLucc<-|{d0B}TYV4% zXb2&i7=1AD!SI3)8eh~m1*=4&58{iwSs#csA*O01#fPrv%$#p`I&2LZW1_h?**W+8 zeD~+OcjivAXI|(X=xa(O6v_hih+@rJ7Fv?xC~cGqiKN=B7Spv&-5SI$th=tNwKRt& zNG0uZAAw7B*deb-OOUWLF6hsafSANsAfveJ2r{`Y#7%b1mC2@1Pl*JMRmM#VZd!0P zDb!7iYzdnQ#>itRNqcdblsL#Z?tQ_<AOlFKM4%(SNpx`s_!Sb*_&2LVUrc>|a{qmIe)!V9 zRVSBRJo4RMj%7T4tY2$kjMX5R=iSJ@b{=~l*;mu=s-pEszF5#@-|>8{mEJzMLuXvi z9m$q`*Bji?lPeb7L1!rEhQ7ugogQ=aaJJy&vd_6HmmTt)ak|>&qP<~L2OIhaSP80m zu06oUl0WLXPKNdMtY>mu?F<_5Yw=HXbkq>(u+~4YeQS^Iv^(uh^%?OJ(|W0QNn&4A zR%I6{TGfvv4EGuK_oM_)$$bR-t730UhCtY%Pi_hAyjOXRP^Kbw*>ZtvI%3D(V#iFx zj(Z1f8EF_W3>XFs1BL;^fMLKeU>NwnGw^HcUB9OeUusDmZ$5v&QmLb-{if>Isl%VO zOaxO;o#?v4_7ly&uy|<3UrC|wN$8^LWNZ5&4xA84@#lj0O`oz@Gn+a#ojUW=meiS< z1*yc@)cIL|1vOBS23o3#Sx>UbW{p{}FkR+SBVQ-`~Db2WABqQ5kCyla@0>dGWt zr_$AG^=$K#R82fJF>JTCAK_uBiQ#&^wLPi0y&p#?mVC9j)@Bz#%*8NZ7%&VN1`Gp+ z0mFb{z%XDKFbo(53GHFkl!k3>XFs1BL;^fMLKeU>GnA{3jSdz9sT2kvkbA z$FvqFk1QqLwhaRP;-d|9P9}$Q!*~bmW7s5*_)Y zcf|a^%~p$Sx**A*l76mAk_3ue=Na)Y7JT?`w^BEV-X`*Tkq0DM6yrE0c1m^)3gTz0 zVgE^qr+=P<@qpK9(Km|!is;cCRcZ2H5y)eYcZR&%{+^zPt$QicdW}U{!5x$~{O5(| zxlsMgf49#myzWi()qo}I4Cjqve=KIdTkP1kh<}hO33aowlA#5>_5}7D74}8wRqAP~ zaKE?@U_ThdFICuQu+KOC*MoSPg@wqvY&74K+0Me3~-v5vMcdq8@b$8P37qwr^+mj_o}vXr1Ez@$CKNoZNc5Jf8QRA!V0+FO;LG z6^g!Vj}$6)$t#vz&mUKI%`{ZW<}&ND85IPKI^|JiXT}TESSWoj^c-}(a<*8QqiFJZ zZq8wVvYA9>`|cQB1Hx=~G-NsSg#?E_)CuV1vuSFzNGQ74r5sf zXOa^6xLCopegPhGf?QF&N=oedP~tujYwi94{ws1s@ighT%|fgtsfnU VGp6#JOGErC8$!UO;2`4oKLFW~1QP%N literal 0 HcmV?d00001 diff --git a/src/lsystem.nim b/src/lsystem.nim new file mode 100644 index 0000000..033f7fd --- /dev/null +++ b/src/lsystem.nim @@ -0,0 +1,202 @@ +import lsystempkg/raylib, lsystempkg/raygui +import math, os +import algorithm, heapqueue, random, options, sequtils, sugar, tables, system + +# Seed RNG with current time +randomize() + +type Term = enum LeafTerm, LineTerm, GoLeft, GoRight, PushTerm, PopTerm +type Terms = seq[Term] + +iterator rewrite(terms: Terms) : Terms = + var currentTerms: Terms = terms + var newTerms: Terms + + while true: + # Reset this each iteration to gather new expansions + newTerms = @[] + for term in currentTerms: + case term: + of LeafTerm: newTerms &= @[LineTerm, LineTerm, PushTerm, GoRight, LeafTerm, PopTerm, GoLeft, LeafTerm] + else: newTerms &= @[term] + currentTerms = newTerms + yield currentTerms + +type StackControl = enum Push, Pop + +# An intruction along with a change in angle and magnitude (i.e. a vector) +type DrawInstruction = object + angle_change: float64 + magnitude: float64 + +type + InstructionKind = enum pkDraw, pkStack + Instruction = object + case kind: InstructionKind + of pkDraw: drawInstruction: DrawInstruction + of pkStack: stackInstruction: StackControl + +proc `$` (i: Instruction): string = + case i.kind: + of pkDraw: return "angle_change = " & $i.drawInstruction.angle_change & ", magnitude = " & $i.drawInstruction.magnitude + of pkStack: return "direction = " & $i.stackInstruction + +iterator axiomToInstructions(maxIterations: int) : Instruction = + let axiom = @[LeafTerm] + var n = 0 + var termsToConvert: Terms + for terms in rewrite(axiom): + n += 1 + if n == maxIterations: + termsToConvert = terms + break + + var magnitudes: seq[float64] = @[18.float64, 34.float64, 50.float64] + let magnitude_weights = [3, 6, 1] + let magnitude_cdf = math.cumsummed(magnitude_weights) + + let angles: seq[float64] = @[10 * 1.618, 20 * 1.618, 30 * 1.618] + let angle_weights = [3, 5, 2] + let angle_cdf = math.cumsummed(angle_weights) + + var angle_delta: float64 + var magnitude: float64 + # every time you encounter a push divide, and a pop multiply + # type Term = enum LeafTerm, LineTerm, GoLeft, GoRight, PushTerm, PopTerm + + # axiom + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: 180, magnitude: 180)) + for term in termsToConvert: + angle_delta = sample(angles, angle_cdf) + magnitude = sample(magnitudes, magnitude_cdf) + case term: + of LeafTerm: + magnitude = magnitude / 1.5 + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: angle_delta, magnitude: magnitude)) + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: 0, magnitude: -magnitude)) # hack + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: -(angle_delta*2), magnitude: magnitude)) + of LineTerm: + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: 0, magnitude: magnitude)) # don't change direction + of GoLeft: + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: angle_delta, magnitude: magnitude)) # change direction to left 45 degrees + of GoRight: + yield Instruction(kind: pkDraw, drawInstruction: DrawInstruction(angle_change: -angle_delta, magnitude: magnitude)) # change direction to right 45 degrees + of PushTerm: + yield Instruction(kind: pkStack, stackInstruction: Push) + of PopTerm: + magnitude = magnitude * 1.5 + yield Instruction(kind: pkStack, stackInstruction: Pop) + +# A Position along with its angle +type Position = object + x: float64 + y: float64 + angle: float64 + +proc `$` (p: Position): string = + return "x = " & $p.x & ", " & "y = " & $p.y & ", " & "angle = " & $p.angle + +# Line (along with the angle relative to origin +type DrawLine = object + start_pos: Vector2 + end_pos: Vector2 + angle: float64 + +proc `$` (d: DrawLine): string = + return "start_pos = " & $d.start_pos & ", " & "end_pos = " & $d.end_pos + +proc calculateNextLine(inst: DrawInstruction, pos: Position) : DrawLine = + # Change the angle + let new_angle = inst.angle_change + pos.angle + + # Use the same magnitude as before + let magnitude = inst.magnitude + + # Convert from polar coordinates to cartesian + let new_x = -(magnitude * cos(degToRad(new_angle))) + let new_y = magnitude * sin(degToRad(new_angle)) + + result.start_pos = Vector2(x: pos.x, y: pos.y) + + # Ending position is relative to the starting position, so add the coordinates + result.end_pos = Vector2(x: result.start_pos.x+new_x, y: result.start_pos.y+new_y) + + result.angle = new_angle + +proc executeProgram(instructions: seq[Instruction], positions: seq[Position], current_pos: Position) : seq[DrawLine] = + # each instruction will be followed by a stack control instruction + if instructions.len <= 0: + echo "Returning" + return @[] + + let inst = instructions[0] + + var nextLine: DrawLine + + case inst.kind: + of pkStack: + if inst.stackInstruction == Push: + return executeProgram(instructions[1..^1], current_pos & positions, current_pos) + elif inst.stackInstruction == Pop: + let newCurrent = positions[0] + return executeProgram(instructions[1..^1], positions[1..^1], newCurrent) + else: + return + of pkDraw: + nextLine = calculateNextLine(inst.drawInstruction, current_pos) + let new_position = Position(x: nextLine.end_pos.x, + y: nextLine.end_pos.y, + angle: nextLine.angle) + # leave the stack alone, set the current position however + return @[nextLine] & executeProgram(instructions[1..^1], positions, new_position) + +proc guiLoop*(instructions: seq[Instruction]) = + # TODO get from xlib + var screenWidth: int = 100 + var screenHeight: int = 100 + + SetConfigFlags(ord(ConfigFlags.FLAG_WINDOW_UNDECORATED)) + + InitWindow(screenWidth, screenHeight, "L-Systems") + + let monitor = GetCurrentMonitor() + screenWidth = (monitor.GetMonitorWidth()).int + screenHeight = (monitor.GetMonitorHeight()).int + + SetWindowSize(screenWidth, screenHeight) + SetWindowTitle("L-Systems") + MaximizeWindow() + + #GuiLoadStyle("styles/terminal/terminal.rgs") + + var mousePos = Vector2(x: 0, y: 0) + var windowPos = Vector2(x: screenWidth.float64, y: screenHeight.float64) + var panOffset = mousePos + + var dragWindow = false + var exitWindow = false + + var restartButton = false + + SetTargetFPS(60) + + # "axiom" + let startingPosition = Position(x: screenWidth/2, y: screenHeight.float64-100, angle: 90) + let drawLines = executeProgram(instructions, @[startingPosition], startingPosition) + + while not exitWindow and not WindowShouldClose(): + BeginDrawing() + + screenWidth = (monitor.GetMonitorWidth() / 2).int + screenHeight = (monitor.GetMonitorHeight() / 2).int + # This must come before anything else! + ClearBackground(BLACK) + for line in drawLines: + DrawLineEx(line.start_pos, line.end_pos, 3, WHITE) + + EndDrawing() + CloseWindow() + +when isMainModule: + #guiLoop() + guiLoop(toSeq(axiomToInstructions(7))) diff --git a/src/lsystempkg/raygui.nim b/src/lsystempkg/raygui.nim new file mode 100644 index 0000000..1356c55 --- /dev/null +++ b/src/lsystempkg/raygui.nim @@ -0,0 +1,354 @@ +# +# raygui v2.9-dev - A simple and easy-to-use immediate-mode gui library +# +# DESCRIPTION: +# +# raygui is a tools-dev-focused immediate-mode-gui library based on raylib but also +# available as a standalone library, as long as input and drawing functions are provided. +# +# Controls provided: +# +# # Container/separators Controls +# - WindowBox +# - GroupBox +# - Line +# - Panel +# +# # Basic Controls +# - Label +# - Button +# - LabelButton --> Label +# - ImageButton --> Button +# - ImageButtonEx --> Button +# - Toggle +# - ToggleGroup --> Toggle +# - CheckBox +# - ComboBox +# - DropdownBox +# - TextBox +# - TextBoxMulti +# - ValueBox --> TextBox +# - Spinner --> Button, ValueBox +# - Slider +# - SliderBar --> Slider +# - ProgressBar +# - StatusBar +# - ScrollBar +# - ScrollPanel +# - DummyRec +# - Grid +# +# # Advance Controls +# - ListView +# - ColorPicker --> ColorPanel, ColorBarHue +# - MessageBox --> Window, Label, Button +# - TextInputBox --> Window, Label, TextBox, Button +# +# It also provides a set of functions for styling the controls based on its properties (size, color). +# +# CONFIGURATION: +# +# #define RAYGUI_IMPLEMENTATION +# Generates the implementation of the library into the included file. +# If not defined, the library is in header only mode and can be included in other headers +# or source files without problems. But only ONE file should hold the implementation. +# +# #define RAYGUI_STATIC (defined by default) +# The generated implementation will stay private inside implementation file and all +# internal symbols and functions will only be visible inside that file. +# +# #define RAYGUI_STANDALONE +# Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined +# internally in the library and input management and drawing functions must be provided by +# the user (check library implementation for further details). +# +# #define RAYGUI_SUPPORT_ICONS +# Includes riconsdata.h header defining a set of 128 icons (binary format) to be used on +# multiple controls and following raygui styles +# +# +# VERSIONS HISTORY: +# 2.9 (17-Mar-2021) Removed tooltip API +# 2.8 (03-May-2020) Centralized rectangles drawing to GuiDrawRectangle() +# 2.7 (20-Feb-2020) Added possible tooltips API +# 2.6 (09-Sep-2019) ADDED: GuiTextInputBox() +# REDESIGNED: GuiListView*(), GuiDropdownBox(), GuiSlider*(), GuiProgressBar(), GuiMessageBox() +# REVIEWED: GuiTextBox(), GuiSpinner(), GuiValueBox(), GuiLoadStyle() +# Replaced property INNER_PADDING by TEXT_PADDING, renamed some properties +# Added 8 new custom styles ready to use +# Multiple minor tweaks and bugs corrected +# 2.5 (28-May-2019) Implemented extended GuiTextBox(), GuiValueBox(), GuiSpinner() +# 2.3 (29-Apr-2019) Added rIcons auxiliar library and support for it, multiple controls reviewed +# Refactor all controls drawing mechanism to use control state +# 2.2 (05-Feb-2019) Added GuiScrollBar(), GuiScrollPanel(), reviewed GuiListView(), removed Gui*Ex() controls +# 2.1 (26-Dec-2018) Redesign of GuiCheckBox(), GuiComboBox(), GuiDropdownBox(), GuiToggleGroup() > Use combined text string +# Complete redesign of style system (breaking change) +# 2.0 (08-Nov-2018) Support controls guiLock and custom fonts, reviewed GuiComboBox(), GuiListView()... +# 1.9 (09-Oct-2018) Controls review: GuiGrid(), GuiTextBox(), GuiTextBoxMulti(), GuiValueBox()... +# 1.8 (01-May-2018) Lot of rework and redesign to align with rGuiStyler and rGuiLayout +# 1.5 (21-Jun-2017) Working in an improved styles system +# 1.4 (15-Jun-2017) Rewritten all GUI functions (removed useless ones) +# 1.3 (12-Jun-2017) Redesigned styles system +# 1.1 (01-Jun-2017) Complete review of the library +# 1.0 (07-Jun-2016) Converted to header-only by Ramon Santamaria. +# 0.9 (07-Mar-2016) Reviewed and tested by Albert Martos, Ian Eito, Sergio Martinez and Ramon Santamaria. +# 0.8 (27-Aug-2015) Initial release. Implemented by Kevin Gato, Daniel Nicolás and Ramon Santamaria. +# +# CONTRIBUTORS: +# Ramon Santamaria: Supervision, review, redesign, update and maintenance... +# Vlad Adrian: Complete rewrite of GuiTextBox() to support extended features (2019) +# Sergio Martinez: Review, testing (2015) and redesign of multiple controls (2018) +# Adria Arranz: Testing and Implementation of additional controls (2018) +# Jordi Jorba: Testing and Implementation of additional controls (2018) +# Albert Martos: Review and testing of the library (2015) +# Ian Eito: Review and testing of the library (2015) +# Kevin Gato: Initial implementation of basic components (2014) +# Daniel Nicolas: Initial implementation of basic components (2014) +# +# +# LICENSE: zlib/libpng +# +# Copyright (c) 2014-2020 Ramon Santamaria (@raysan5) +# +# This software is provided "as-is", without any express or implied warranty. In no event +# will the authors be held liable for any damages arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, including commercial +# applications, and to alter it and redistribute it freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not claim that you +# wrote the original software. If you use this software in a product, an acknowledgment +# in the product documentation would be appreciated but is not required. +# +# 2. Altered source versions must be plainly marked as such, and must not be misrepresented +# as being the original software. +# +# 3. This notice may not be removed or altered from any source distribution. +# +template RAYGUI_H*(): auto = RAYGUI_H +template RAYGUI_VERSION*(): auto = "2.9-dev" +import raylib +# Define functions scope to be used internally (static) or externally (extern) to the module including this file +{.pragma: RAYGUIDEF, cdecl, discardable, dynlib: "raygui" & LEXT.} +# Allow custom memory allocators +# ---------------------------------------------------------------------------------- +# Defines and Macros +# ---------------------------------------------------------------------------------- +template NUM_CONTROLS*(): auto = 16 +template NUM_PROPS_DEFAULT*(): auto = 16 +template NUM_PROPS_EXTENDED*(): auto = 8 +template TEXTEDIT_CURSOR_BLINK_FRAMES*(): auto = 20 +# ---------------------------------------------------------------------------------- +# Types and Structures Definition +# NOTE: Some types are required for RAYGUI_STANDALONE usage +# ---------------------------------------------------------------------------------- +# Style property +type GuiStyleProp* {.bycopy.} = object + controlId*: uint16 + propertyId*: uint16 + propertyValue*: int32 +# Gui control state +type GuiControlState* = enum + GUI_STATE_NORMAL = 0 + GUI_STATE_FOCUSED + GUI_STATE_PRESSED + GUI_STATE_DISABLED +converter GuiControlState2int32* (self: GuiControlState): int32 = self.int32 +# Gui control text alignment +type GuiTextAlignment* = enum + GUI_TEXT_ALIGN_LEFT = 0 + GUI_TEXT_ALIGN_CENTER + GUI_TEXT_ALIGN_RIGHT +converter GuiTextAlignment2int32* (self: GuiTextAlignment): int32 = self.int32 +# Gui controls +type GuiControl* = enum + DEFAULT = 0 + LABEL # LABELBUTTON + BUTTON # IMAGEBUTTON + TOGGLE # TOGGLEGROUP + SLIDER # SLIDERBAR + PROGRESSBAR + CHECKBOX + COMBOBOX + DROPDOWNBOX + TEXTBOX # TEXTBOXMULTI + VALUEBOX + SPINNER + LISTVIEW + COLORPICKER + SCROLLBAR + STATUSBAR +converter GuiControl2int32* (self: GuiControl): int32 = self.int32 +# Gui base properties for every control +type GuiControlProperty* = enum + BORDER_COLOR_NORMAL = 0 + BASE_COLOR_NORMAL + TEXT_COLOR_NORMAL + BORDER_COLOR_FOCUSED + BASE_COLOR_FOCUSED + TEXT_COLOR_FOCUSED + BORDER_COLOR_PRESSED + BASE_COLOR_PRESSED + TEXT_COLOR_PRESSED + BORDER_COLOR_DISABLED + BASE_COLOR_DISABLED + TEXT_COLOR_DISABLED + BORDER_WIDTH + TEXT_PADDING + TEXT_ALIGNMENT + RESERVED +converter GuiControlProperty2int32* (self: GuiControlProperty): int32 = self.int32 +# Gui extended properties depend on control +# NOTE: We reserve a fixed size of additional properties per control +# DEFAULT properties +type GuiDefaultProperty* = enum + TEXT_SIZE = 16 + TEXT_SPACING + LINE_COLOR + BACKGROUND_COLOR +converter GuiDefaultProperty2int32* (self: GuiDefaultProperty): int32 = self.int32 +# Label +# typedef enum { } GuiLabelProperty; +# Button +# typedef enum { } GuiButtonProperty; +# Toggle / ToggleGroup +type GuiToggleProperty* = enum + GROUP_PADDING = 16 +converter GuiToggleProperty2int32* (self: GuiToggleProperty): int32 = self.int32 +# Slider / SliderBar +type GuiSliderProperty* = enum + SLIDER_WIDTH = 16 + SLIDER_PADDING +converter GuiSliderProperty2int32* (self: GuiSliderProperty): int32 = self.int32 +# ProgressBar +type GuiProgressBarProperty* = enum + PROGRESS_PADDING = 16 +converter GuiProgressBarProperty2int32* (self: GuiProgressBarProperty): int32 = self.int32 +# CheckBox +type GuiCheckBoxProperty* = enum + CHECK_PADDING = 16 +converter GuiCheckBoxProperty2int32* (self: GuiCheckBoxProperty): int32 = self.int32 +# ComboBox +type GuiComboBoxProperty* = enum + COMBO_BUTTON_WIDTH = 16 + COMBO_BUTTON_PADDING +converter GuiComboBoxProperty2int32* (self: GuiComboBoxProperty): int32 = self.int32 +# DropdownBox +type GuiDropdownBoxProperty* = enum + ARROW_PADDING = 16 + DROPDOWN_ITEMS_PADDING +converter GuiDropdownBoxProperty2int32* (self: GuiDropdownBoxProperty): int32 = self.int32 +# TextBox / TextBoxMulti / ValueBox / Spinner +type GuiTextBoxProperty* = enum + TEXT_INNER_PADDING = 16 + TEXT_LINES_PADDING + COLOR_SELECTED_FG + COLOR_SELECTED_BG +converter GuiTextBoxProperty2int32* (self: GuiTextBoxProperty): int32 = self.int32 +# Spinner +type GuiSpinnerProperty* = enum + SPIN_BUTTON_WIDTH = 16 + SPIN_BUTTON_PADDING +converter GuiSpinnerProperty2int32* (self: GuiSpinnerProperty): int32 = self.int32 +# ScrollBar +type GuiScrollBarProperty* = enum + ARROWS_SIZE = 16 + ARROWS_VISIBLE + SCROLL_SLIDER_PADDING + SCROLL_SLIDER_SIZE + SCROLL_PADDING + SCROLL_SPEED +converter GuiScrollBarProperty2int32* (self: GuiScrollBarProperty): int32 = self.int32 +# ScrollBar side +type GuiScrollBarSide* = enum + SCROLLBAR_LEFT_SIDE = 0 + SCROLLBAR_RIGHT_SIDE +converter GuiScrollBarSide2int32* (self: GuiScrollBarSide): int32 = self.int32 +# ListView +type GuiListViewProperty* = enum + LIST_ITEMS_HEIGHT = 16 + LIST_ITEMS_PADDING + SCROLLBAR_WIDTH + SCROLLBAR_SIDE +converter GuiListViewProperty2int32* (self: GuiListViewProperty): int32 = self.int32 +# ColorPicker +type GuiColorPickerProperty* = enum + COLOR_SELECTOR_SIZE = 16 + HUEBAR_WIDTH # Right hue bar width + HUEBAR_PADDING # Right hue bar separation from panel + HUEBAR_SELECTOR_HEIGHT # Right hue bar selector height + HUEBAR_SELECTOR_OVERFLOW # Right hue bar selector overflow +converter GuiColorPickerProperty2int32* (self: GuiColorPickerProperty): int32 = self.int32 +# ---------------------------------------------------------------------------------- +# Global Variables Definition +# ---------------------------------------------------------------------------------- +# ... +# ---------------------------------------------------------------------------------- +# Module Functions Declaration +# ---------------------------------------------------------------------------------- +# State modification functions +proc GuiEnable*() {.RAYGUIDEF, importc: "GuiEnable".} # Enable gui controls (global state) +proc GuiDisable*() {.RAYGUIDEF, importc: "GuiDisable".} # Disable gui controls (global state) +proc GuiLock*() {.RAYGUIDEF, importc: "GuiLock".} # Lock gui controls (global state) +proc GuiUnlock*() {.RAYGUIDEF, importc: "GuiUnlock".} # Unlock gui controls (global state) +proc GuiFade*(alpha: float32) {.RAYGUIDEF, importc: "GuiFade".} # Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f +proc GuiSetState*(state: int32) {.RAYGUIDEF, importc: "GuiSetState".} # Set gui state (global state) +proc GuiGetState*(): int32 {.RAYGUIDEF, importc: "GuiGetState".} # Get gui state (global state) +# Font set/get functions +proc GuiSetFont*(font: Font) {.RAYGUIDEF, importc: "GuiSetFont".} # Set gui custom font (global state) +proc GuiGetFont*(): Font {.RAYGUIDEF, importc: "GuiGetFont".} # Get gui custom font (global state) +# Style set/get functions +proc GuiSetStyle*(control: int32; property: int32; value: int32) {.RAYGUIDEF, importc: "GuiSetStyle".} # Set one style property +proc GuiGetStyle*(control: int32; property: int32): int32 {.RAYGUIDEF, importc: "GuiGetStyle".} # Get one style property +# Container/separator controls, useful for controls organization +proc GuiWindowBox*(bounds: Rectangle; title: cstring): bool {.RAYGUIDEF, importc: "GuiWindowBox".} # Window Box control, shows a window that can be closed +proc GuiGroupBox*(bounds: Rectangle; text: cstring) {.RAYGUIDEF, importc: "GuiGroupBox".} # Group Box control with text name +proc GuiLine*(bounds: Rectangle; text: cstring) {.RAYGUIDEF, importc: "GuiLine".} # Line separator control, could contain text +proc GuiPanel*(bounds: Rectangle) {.RAYGUIDEF, importc: "GuiPanel".} # Panel control, useful to group controls +proc GuiScrollPanel*(bounds: Rectangle; content: Rectangle; scroll: ptr Vector2): Rectangle {.RAYGUIDEF, importc: "GuiScrollPanel".} # Scroll Panel control +# Basic controls set +proc GuiLabel*(bounds: Rectangle; text: cstring) {.RAYGUIDEF, importc: "GuiLabel".} # Label control, shows text +proc GuiButton*(bounds: Rectangle; text: cstring): bool {.RAYGUIDEF, importc: "GuiButton".} # Button control, returns true when clicked +proc GuiLabelButton*(bounds: Rectangle; text: cstring): bool {.RAYGUIDEF, importc: "GuiLabelButton".} # Label button control, show true when clicked +proc GuiImageButton*(bounds: Rectangle; text: cstring; texture: Texture2D): bool {.RAYGUIDEF, importc: "GuiImageButton".} # Image button control, returns true when clicked +proc GuiImageButtonEx*(bounds: Rectangle; text: cstring; texture: Texture2D; texSource: Rectangle): bool {.RAYGUIDEF, importc: "GuiImageButtonEx".} # Image button extended control, returns true when clicked +proc GuiToggle*(bounds: Rectangle; text: cstring; active: bool): bool {.RAYGUIDEF, importc: "GuiToggle".} # Toggle Button control, returns true when active +proc GuiToggleGroup*(bounds: Rectangle; text: cstring; active: int32): int32 {.RAYGUIDEF, importc: "GuiToggleGroup".} # Toggle Group control, returns active toggle index +proc GuiCheckBox*(bounds: Rectangle; text: cstring; checked: bool): bool {.RAYGUIDEF, importc: "GuiCheckBox".} # Check Box control, returns true when active +proc GuiComboBox*(bounds: Rectangle; text: cstring; active: int32): int32 {.RAYGUIDEF, importc: "GuiComboBox".} # Combo Box control, returns selected item index +proc GuiDropdownBox*(bounds: Rectangle; text: cstring; active: pointer; editMode: bool): bool {.RAYGUIDEF, importc: "GuiDropdownBox".} # Dropdown Box control, returns selected item +proc GuiSpinner*(bounds: Rectangle; text: cstring; value: pointer; minValue: int32; maxValue: int32; editMode: bool): bool {.RAYGUIDEF, importc: "GuiSpinner".} # Spinner control, returns selected value +proc GuiValueBox*(bounds: Rectangle; text: cstring; value: pointer; minValue: int32; maxValue: int32; editMode: bool): bool {.RAYGUIDEF, importc: "GuiValueBox".} # Value Box control, updates input text with numbers +proc GuiTextBox*(bounds: Rectangle; text: ptr char; textSize: int32; editMode: bool): bool {.RAYGUIDEF, importc: "GuiTextBox".} # Text Box control, updates input text +proc GuiTextBoxMulti*(bounds: Rectangle; text: ptr char; textSize: int32; editMode: bool): bool {.RAYGUIDEF, importc: "GuiTextBoxMulti".} # Text Box control with multiple lines +proc GuiSlider*(bounds: Rectangle; textLeft: cstring; textRight: cstring; value: float32; minValue: float32; maxValue: float32): float32 {.RAYGUIDEF, importc: "GuiSlider".} # Slider control, returns selected value +proc GuiSliderBar*(bounds: Rectangle; textLeft: cstring; textRight: cstring; value: float32; minValue: float32; maxValue: float32): float32 {.RAYGUIDEF, importc: "GuiSliderBar".} # Slider Bar control, returns selected value +proc GuiProgressBar*(bounds: Rectangle; textLeft: cstring; textRight: cstring; value: float32; minValue: float32; maxValue: float32): float32 {.RAYGUIDEF, importc: "GuiProgressBar".} # Progress Bar control, shows current progress value +proc GuiStatusBar*(bounds: Rectangle; text: cstring) {.RAYGUIDEF, importc: "GuiStatusBar".} # Status Bar control, shows info text +proc GuiDummyRec*(bounds: Rectangle; text: cstring) {.RAYGUIDEF, importc: "GuiDummyRec".} # Dummy control for placeholders +proc GuiScrollBar*(bounds: Rectangle; value: int32; minValue: int32; maxValue: int32): int32 {.RAYGUIDEF, importc: "GuiScrollBar".} # Scroll Bar control +proc GuiGrid*(bounds: Rectangle; spacing: float32; subdivs: int32): Vector2 {.RAYGUIDEF, importc: "GuiGrid".} # Grid control +# Advance controls set +proc GuiListView*(bounds: Rectangle; text: cstring; scrollIndex: pointer; active: int32): int32 {.RAYGUIDEF, importc: "GuiListView".} # List View control, returns selected list item index +proc GuiListViewEx*(bounds: Rectangle; text: cstring; count: int32; focus: pointer; scrollIndex: pointer; active: int32): int32 {.RAYGUIDEF, importc: "GuiListViewEx".} # List View with extended parameters +proc GuiMessageBox*(bounds: Rectangle; title: cstring; message: cstring; buttons: cstring): int32 {.RAYGUIDEF, importc: "GuiMessageBox".} # Message Box control, displays a message +proc GuiTextInputBox*(bounds: Rectangle; title: cstring; message: cstring; buttons: cstring; text: ptr char): int32 {.RAYGUIDEF, importc: "GuiTextInputBox".} # Text Input Box control, ask for text +proc GuiColorPicker*(bounds: Rectangle; color: Color): Color {.RAYGUIDEF, importc: "GuiColorPicker".} # Color Picker control (multiple color controls) +proc GuiColorPanel*(bounds: Rectangle; color: Color): Color {.RAYGUIDEF, importc: "GuiColorPanel".} # Color Panel control +proc GuiColorBarAlpha*(bounds: Rectangle; alpha: float32): float32 {.RAYGUIDEF, importc: "GuiColorBarAlpha".} # Color Bar Alpha control +proc GuiColorBarHue*(bounds: Rectangle; value: float32): float32 {.RAYGUIDEF, importc: "GuiColorBarHue".} # Color Bar Hue control +# Styles loading functions +proc GuiLoadStyle*(fileName: cstring) {.RAYGUIDEF, importc: "GuiLoadStyle".} # Load style file (.rgs) +proc GuiLoadStyleDefault*() {.RAYGUIDEF, importc: "GuiLoadStyleDefault".} # Load style default over global style +proc GuiIconText*(iconId: int32; text: cstring): cstring {.RAYGUIDEF, importc: "GuiIconText".} # Get text with icon id prepended (if supported) +# Gui icons functionality +proc GuiDrawIcon*(iconId: int32; position: Vector2; pixelSize: int32; color: Color) {.RAYGUIDEF, importc: "GuiDrawIcon".} +proc GuiGetIcons*(): uint32 {.RAYGUIDEF, importc: "GuiGetIcons".} # Get full icons data pointer +proc GuiGetIconData*(iconId: int32): uint32 {.RAYGUIDEF, importc: "GuiGetIconData".} # Get icon bit data +proc GuiSetIconData*(iconId: int32; data: uint32) {.RAYGUIDEF, importc: "GuiSetIconData".} # Set icon bit data +proc GuiSetIconPixel*(iconId: int32; x: int32; y: int32) {.RAYGUIDEF, importc: "GuiSetIconPixel".} # Set icon pixel value +proc GuiClearIconPixel*(iconId: int32; x: int32; y: int32) {.RAYGUIDEF, importc: "GuiClearIconPixel".} # Clear icon pixel value +proc GuiCheckIconPixel*(iconId: int32; x: int32; y: int32): bool {.RAYGUIDEF, importc: "GuiCheckIconPixel".} # Check icon pixel value +# +# RAYGUI IMPLEMENTATION +# diff --git a/src/lsystempkg/raylib.nim b/src/lsystempkg/raylib.nim new file mode 100644 index 0000000..a7c772a --- /dev/null +++ b/src/lsystempkg/raylib.nim @@ -0,0 +1,1291 @@ +# +# raylib - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com) +# +# FEATURES: +# - NO external dependencies, all required libraries included with raylib +# - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, +# MacOS, Haiku, UWP, Android, Raspberry Pi, HTML5. +# - Written in plain C code (C99) in PascalCase/camelCase notation +# - Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES2 - choose at compile) +# - Unique OpenGL abstraction layer (usable as standalone module): [rlgl] +# - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts) +# - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC) +# - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more! +# - Flexible Materials system, supporting classic maps and PBR maps +# - Animated 3D models supported (skeletal bones animation) (IQM, glTF) +# - Shaders support, including Model shaders and Postprocessing shaders +# - Powerful math module for Vector, Matrix and Quaternion operations: [raymath] +# - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD) +# - VR stereo rendering with configurable HMD device parameters +# - Bindings to multiple programming languages available! +# +# NOTES: +# One default Font is loaded on InitWindow()->LoadFontDefault() [core, text] +# One default Texture2D is loaded on rlglInit() [rlgl] (OpenGL 3.3 or ES2) +# One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2) +# One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2) +# +# DEPENDENCIES (included): +# [core] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP) +# [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP) +# [raudio] miniaudio (David Reid - github.com/dr-soft/miniaudio) for audio device/context management +# +# OPTIONAL DEPENDENCIES (included): +# [core] msf_gif (Miles Fogle) for GIF recording +# [core] sinfl (Micha Mettke) for DEFLATE decompression algorythm +# [core] sdefl (Micha Mettke) for DEFLATE compression algorythm +# [textures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) +# [textures] stb_image_write (Sean Barret) for image writting (BMP, TGA, PNG, JPG) +# [textures] stb_image_resize (Sean Barret) for image resizing algorithms +# [textures] stb_perlin (Sean Barret) for Perlin noise image generation +# [text] stb_truetype (Sean Barret) for ttf fonts loading +# [text] stb_rect_pack (Sean Barret) for rectangles packing +# [models] par_shapes (Philip Rideout) for parametric 3d shapes generation +# [models] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL) +# [models] cgltf (Johannes Kuhlmann) for models loading (glTF) +# [raudio] dr_wav (David Reid) for WAV audio file loading +# [raudio] dr_flac (David Reid) for FLAC audio file loading +# [raudio] dr_mp3 (David Reid) for MP3 audio file loading +# [raudio] stb_vorbis (Sean Barret) for OGG audio loading +# [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading +# [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading +# +# +# LICENSE: zlib/libpng +# +# raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified, +# BSD-like license that allows static linking with closed source software: +# +# Copyright (c) 2013-2021 Ramon Santamaria (@raysan5) +# +# This software is provided "as-is", without any express or implied warranty. In no event +# will the authors be held liable for any damages arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, including commercial +# applications, and to alter it and redistribute it freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not claim that you +# wrote the original software. If you use this software in a product, an acknowledgment +# in the product documentation would be appreciated but is not required. +# +# 2. Altered source versions must be plainly marked as such, and must not be misrepresented +# as being the original software. +# +# 3. This notice may not be removed or altered from any source distribution. +# +converter int2in32* (self: int): int32 = self.int32 +const LEXT* = when defined(windows):".dll" +elif defined(macosx): ".dylib" +else: ".so" +template RAYLIB_VERSION*(): auto = "3.8-dev" +{.pragma: RLAPI, cdecl, discardable, dynlib: "libraylib" & LEXT.} +# ---------------------------------------------------------------------------------- +# Some basic Defines +# ---------------------------------------------------------------------------------- +template DEG2RAD*(): auto = (PI/180.0f) +template RAD2DEG*(): auto = (180.0f/PI) +# Allow custom memory allocators +# NOTE: MSVC C++ compiler does not support compound literals (C99 feature) +# Plain structures in C++ (without constructors) can be initialized with { } +# Some Basic Colors +# NOTE: Custom raylib color palette for amazing visuals on WHITE background +template LIGHTGRAY*(): auto = Color(r: 200, g: 200, b: 200, a: 255) # Light Gray +template GRAY*(): auto = Color(r: 130, g: 130, b: 130, a: 255) # Gray +template DARKGRAY*(): auto = Color(r: 80, g: 80, b: 80, a: 255) # Dark Gray +template YELLOW*(): auto = Color(r: 253, g: 249, b: 0, a: 255) # Yellow +template GOLD*(): auto = Color(r: 255, g: 203, b: 0, a: 255) # Gold +template ORANGE*(): auto = Color(r: 255, g: 161, b: 0, a: 255) # Orange +template PINK*(): auto = Color(r: 255, g: 109, b: 194, a: 255) # Pink +template RED*(): auto = Color(r: 230, g: 41, b: 55, a: 255) # Red +template MAROON*(): auto = Color(r: 190, g: 33, b: 55, a: 255) # Maroon +template GREEN*(): auto = Color(r: 0, g: 228, b: 48, a: 255) # Green +template LIME*(): auto = Color(r: 0, g: 158, b: 47, a: 255) # Lime +template DARKGREEN*(): auto = Color(r: 0, g: 117, b: 44, a: 255) # Dark Green +template SKYBLUE*(): auto = Color(r: 102, g: 191, b: 255, a: 255) # Sky Blue +template BLUE*(): auto = Color(r: 0, g: 121, b: 241, a: 255) # Blue +template DARKBLUE*(): auto = Color(r: 0, g: 82, b: 172, a: 255) # Dark Blue +template PURPLE*(): auto = Color(r: 200, g: 122, b: 255, a: 255) # Purple +template VIOLET*(): auto = Color(r: 135, g: 60, b: 190, a: 255) # Violet +template DARKPURPLE*(): auto = Color(r: 112, g: 31, b: 126, a: 255) # Dark Purple +template BEIGE*(): auto = Color(r: 211, g: 176, b: 131, a: 255) # Beige +template BROWN*(): auto = Color(r: 127, g: 106, b: 79, a: 255) # Brown +template DARKBROWN*(): auto = Color(r: 76, g: 63, b: 47, a: 255) # Dark Brown +template WHITE*(): auto = Color(r: 255, g: 255, b: 255, a: 255) # White +template BLACK*(): auto = Color(r: 0, g: 0, b: 0, a: 255) # Black +template BLANK*(): auto = Color(r: 0, g: 0, b: 0, a: 0) # Blank (Transparent) +template MAGENTA*(): auto = Color(r: 255, g: 0, b: 255, a: 255) # Magenta +template RAYWHITE*(): auto = Color(r: 245, g: 245, b: 245, a: 255) # My own White (raylib logo) +# WARNING: Temporal hacks to avoid breaking old codebases using +# deprecated raylib implementations or definitions +# Definition of GetImageData was moved to EOF. +template FILTER_POINT*(): auto = TEXTURE_FILTER_POINT +template FILTER_BILINEAR*(): auto = TEXTURE_FILTER_BILINEAR +template MAP_DIFFUSE*(): auto = MATERIAL_MAP_DIFFUSE +template UNCOMPRESSED_R8G8B8A8*(): auto = PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 +# ---------------------------------------------------------------------------------- +# Structures Definition +# ---------------------------------------------------------------------------------- +# Boolean type +# Vector2, 2 components +type Vector2* {.bycopy.} = object + x*: float32 # Vector x component + y*: float32 # Vector y component +# Vector3, 3 components +type Vector3* {.bycopy.} = object + x*: float32 # Vector x component + y*: float32 # Vector y component + z*: float32 # Vector z component +# Vector4, 4 components +type Vector4* {.bycopy.} = object + x*: float32 # Vector x component + y*: float32 # Vector y component + z*: float32 # Vector z component + w*: float32 # Vector w component +# Quaternion, 4 components (Vector4 alias) +type Quaternion* = Vector4 +# Matrix, 4x4 components, column major, OpenGL style, right handed +type Matrix* {.bycopy.} = object + m0*, m4*, m8*, m12*: float32 # Matrix first row (4 components) + m1*, m5*, m9*, m13*: float32 # Matrix second row (4 components) + m2*, m6*, m10*, m14*: float32 # Matrix third row (4 components) + m3*, m7*, m11*, m15*: float32 # Matrix fourth row (4 components) +# Color, 4 components, R8G8B8A8 (32bit) +type Color* {.bycopy.} = object + r*: uint8 # Color red value + g*: uint8 # Color green value + b*: uint8 # Color blue value + a*: uint8 # Color alpha value +# Rectangle, 4 components +type Rectangle* {.bycopy.} = object + x*: float32 # Rectangle top-left corner position x + y*: float32 # Rectangle top-left corner position y + width*: float32 # Rectangle width + height*: float32 # Rectangle height +# Image, pixel data stored in CPU memory (RAM) +type Image* {.bycopy.} = object + data*: pointer # Image raw data + width*: int32 # Image base width + height*: int32 # Image base height + mipmaps*: int32 # Mipmap levels, 1 by default + format*: int32 # Data format (PixelFormat type) +# Texture, tex data stored in GPU memory (VRAM) +type Texture* {.bycopy.} = object + id*: uint32 # OpenGL texture id + width*: int32 # Texture base width + height*: int32 # Texture base height + mipmaps*: int32 # Mipmap levels, 1 by default + format*: int32 # Data format (PixelFormat type) +# Texture2D, same as Texture +type Texture2D* = Texture +# TextureCubemap, same as Texture +type TextureCubemap* = Texture +# RenderTexture, fbo for texture rendering +type RenderTexture* {.bycopy.} = object + id*: uint32 # OpenGL framebuffer object id + texture*: Texture # Color buffer attachment texture + depth*: Texture # Depth buffer attachment texture +# RenderTexture2D, same as RenderTexture +type RenderTexture2D* = RenderTexture +# NPatchInfo, n-patch layout info +type NPatchInfo* {.bycopy.} = object + source*: Rectangle # Texture source rectangle + left*: int32 # Left border offset + top*: int32 # Top border offset + right*: int32 # Right border offset + bottom*: int32 # Bottom border offset + layout*: int32 # Layout of the n-patch: 3x3, 1x3 or 3x1 +# CharInfo, font character info +type CharInfo* {.bycopy.} = object + value*: int32 # Character value (Unicode) + offsetX*: int32 # Character offset X when drawing + offsetY*: int32 # Character offset Y when drawing + advanceX*: int32 # Character advance position X + image*: Image # Character image data +# Font, font texture and CharInfo array data +type Font* {.bycopy.} = object + baseSize*: int32 # Base size (default chars height) + charsCount*: int32 # Number of characters + charsPadding*: int32 # Padding around the chars + texture*: Texture2D # Characters texture atlas + recs*: ptr Rectangle # Characters rectangles in texture + chars*: ptr CharInfo # Characters info data +# Camera, defines position/orientation in 3d space +type Camera3D* {.bycopy.} = object + position*: Vector3 # Camera position + target*: Vector3 # Camera target it looks-at + up*: Vector3 # Camera up vector (rotation over its axis) + fovy*: float32 # Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic + projection*: int32 # Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC +type Camera* = Camera3D +# Camera2D, defines position/orientation in 2d space +type Camera2D* {.bycopy.} = object + offset*: Vector2 # Camera offset (displacement from target) + target*: Vector2 # Camera target (rotation and zoom origin) + rotation*: float32 # Camera rotation in degrees + zoom*: float32 # Camera zoom (scaling), should be 1.0f by default +# Mesh, vertex data and vao/vbo +type Mesh* {.bycopy.} = object + vertexCount*: int32 # Number of vertices stored in arrays + triangleCount*: int32 # Number of triangles stored (indexed or not) + vertices*: float32 # Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + texcoords*: float32 # Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + texcoords2*: float32 # Vertex second texture coordinates (useful for lightmaps) (shader-location = 5) + normals*: float32 # Vertex normals (XYZ - 3 components per vertex) (shader-location = 2) + tangents*: float32 # Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4) + colors*: uint8 # Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + indices*: uint16 # Vertex indices (in case vertex data comes indexed) + animVertices*: float32 # Animated vertex positions (after bones transformations) + animNormals*: float32 # Animated normals (after bones transformations) + boneIds*: pointer # Vertex bone ids, up to 4 bones influence by vertex (skinning) + boneWeights*: float32 # Vertex bone weight, up to 4 bones influence by vertex (skinning) + vaoId*: uint32 # OpenGL Vertex Array Object id + vboId*: uint32 # OpenGL Vertex Buffer Objects id (default vertex data) +# Shader +type Shader* {.bycopy.} = object + id*: uint32 # Shader program id + locs*: pointer # Shader locations array (MAX_SHADER_LOCATIONS) +# MaterialMap +type MaterialMap* {.bycopy.} = object + texture*: Texture2D # Material map texture + color*: Color # Material map color + value*: float32 # Material map value +# Material, includes shader and maps +type Material* {.bycopy.} = object + shader*: Shader # Material shader + maps*: ptr MaterialMap # Material maps array (MAX_MATERIAL_MAPS) + params*: array[0..3, float32] # Material generic parameters (if required) +# Transform, vectex transformation data +type Transform* {.bycopy.} = object + translation*: Vector3 # Translation + rotation*: Quaternion # Rotation + scale*: Vector3 # Scale +# Bone, skeletal animation bone +type BoneInfo* {.bycopy.} = object + name*: array[0..31, char] # Bone name + parent*: int32 # Bone parent +# Model, meshes, materials and animation data +type Model* {.bycopy.} = object + transform*: Matrix # Local transform matrix + meshCount*: int32 # Number of meshes + materialCount*: int32 # Number of materials + meshes*: ptr Mesh # Meshes array + materials*: ptr Material # Materials array + meshMaterial*: pointer # Mesh material number + boneCount*: int32 # Number of bones + bones*: ptr BoneInfo # Bones information (skeleton) + bindPose*: ptr Transform # Bones base transformation (pose) +# ModelAnimation +type ModelAnimation* {.bycopy.} = object + boneCount*: int32 # Number of bones + frameCount*: int32 # Number of animation frames + bones*: ptr BoneInfo # Bones information (skeleton) + framePoses*: ptr Transform # Poses array by frame +# Ray, ray for raycasting +type Ray* {.bycopy.} = object + position*: Vector3 # Ray position (origin) + direction*: Vector3 # Ray direction +# RayCollision, ray hit information +type RayCollision* {.bycopy.} = object + hit*: bool # Did the ray hit something? + distance*: float32 # Distance to nearest hit + point*: Vector3 # Point of nearest hit + normal*: Vector3 # Surface normal of hit +# BoundingBox +type BoundingBox* {.bycopy.} = object + min*: Vector3 # Minimum vertex box-corner + max*: Vector3 # Maximum vertex box-corner +# Wave, audio wave data +type Wave* {.bycopy.} = object + sampleCount*: uint32 # Total number of samples (considering channels!) + sampleRate*: uint32 # Frequency (samples per second) + sampleSize*: uint32 # Bit depth (bits per sample): 8, 16, 32 (24 not supported) + channels*: uint32 # Number of channels (1-mono, 2-stereo) + data*: pointer # Buffer data pointer +type rAudioBuffer* {.bycopy.} = object +# AudioStream, custom audio stream +type AudioStream* {.bycopy.} = object + buffer*: ptr rAudioBuffer # Pointer to internal data used by the audio system + sampleRate*: uint32 # Frequency (samples per second) + sampleSize*: uint32 # Bit depth (bits per sample): 8, 16, 32 (24 not supported) + channels*: uint32 # Number of channels (1-mono, 2-stereo) +# Sound +type Sound* {.bycopy.} = object + stream*: AudioStream # Audio stream + sampleCount*: uint32 # Total number of samples +# Music, audio stream, anything longer than ~10 seconds should be streamed +type Music* {.bycopy.} = object + stream*: AudioStream # Audio stream + sampleCount*: uint32 # Total number of samples + looping*: bool # Music looping enable + ctxType*: int32 # Type of music context (audio filetype) + ctxData*: pointer # Audio context data, depends on type +# VrDeviceInfo, Head-Mounted-Display device parameters +type VrDeviceInfo* {.bycopy.} = object + hResolution*: int32 # Horizontal resolution in pixels + vResolution*: int32 # Vertical resolution in pixels + hScreenSize*: float32 # Horizontal size in meters + vScreenSize*: float32 # Vertical size in meters + vScreenCenter*: float32 # Screen center in meters + eyeToScreenDistance*: float32 # Distance between eye and display in meters + lensSeparationDistance*: float32 # Lens separation distance in meters + interpupillaryDistance*: float32 # IPD (distance between pupils) in meters + lensDistortionValues*: array[0..3, float32] # Lens distortion constant parameters + chromaAbCorrection*: array[0..3, float32] # Chromatic aberration correction parameters +# VrStereoConfig, VR stereo rendering configuration for simulator +type VrStereoConfig* {.bycopy.} = object + projection*: array[0..1, Matrix] # VR projection matrices (per eye) + viewOffset*: array[0..1, Matrix] # VR view offset matrices (per eye) + leftLensCenter*: array[0..1, float32] # VR left lens center + rightLensCenter*: array[0..1, float32] # VR right lens center + leftScreenCenter*: array[0..1, float32] # VR left screen center + rightScreenCenter*: array[0..1, float32] # VR right screen center + scale*: array[0..1, float32] # VR distortion scale + scaleIn*: array[0..1, float32] # VR distortion scale in +# ---------------------------------------------------------------------------------- +# Enumerators Definition +# ---------------------------------------------------------------------------------- +# System/Window config flags +# NOTE: Every bit registers one state (use it with bit masks) +# By default all flags are set to 0 +type ConfigFlags* = enum + FLAG_FULLSCREEN_MODE = 0x00000002 # Set to run program in fullscreen + FLAG_WINDOW_RESIZABLE = 0x00000004 # Set to allow resizable window + FLAG_WINDOW_UNDECORATED = 0x00000008 # Set to disable window decoration (frame and buttons) + FLAG_WINDOW_TRANSPARENT = 0x00000010 # Set to allow transparent framebuffer + FLAG_MSAA_4X_HINT = 0x00000020 # Set to try enabling MSAA 4X + FLAG_VSYNC_HINT = 0x00000040 # Set to try enabling V-Sync on GPU + FLAG_WINDOW_HIDDEN = 0x00000080 # Set to hide window + FLAG_WINDOW_ALWAYS_RUN = 0x00000100 # Set to allow windows running while minimized + FLAG_WINDOW_MINIMIZED = 0x00000200 # Set to minimize window (iconify) + FLAG_WINDOW_MAXIMIZED = 0x00000400 # Set to maximize window (expanded to monitor) + FLAG_WINDOW_UNFOCUSED = 0x00000800 # Set to window non focused + FLAG_WINDOW_TOPMOST = 0x00001000 # Set to window always on top + FLAG_WINDOW_HIGHDPI = 0x00002000 # Set to support HighDPI + FLAG_INTERLACED_HINT = 0x00010000 # Set to try enabling interlaced video format (for V3D) +converter ConfigFlags2int32* (self: ConfigFlags): int32 = self.int32 +# Trace log level +# NOTE: Organized by priority level +type TraceLogLevel* = enum + LOG_ALL = 0 # Display all logs + LOG_TRACE # Trace logging, intended for internal use only + LOG_DEBUG # Debug logging, used for internal debugging, it should be disabled on release builds + LOG_INFO # Info logging, used for program execution info + LOG_WARNING # Warning logging, used on recoverable failures + LOG_ERROR # Error logging, used on unrecoverable failures + LOG_FATAL # Fatal logging, used to abort program: exit(EXIT_FAILURE) + LOG_NONE # Disable logging +converter TraceLogLevel2int32* (self: TraceLogLevel): int32 = self.int32 +# Keyboard keys (US keyboard layout) +# NOTE: Use GetKeyPressed() to allow redefining +# required keys for alternative layouts +type KeyboardKey* = enum + KEY_NULL = 0 # Key: NULL, used for no key pressed + KEY_BACK = 4 # Key: Android back button + KEY_VOLUME_UP = 24 # Key: Android volume up button + KEY_VOLUME_DOWN = 25 # Key: Android volume down button + KEY_SPACE = 32 # Key: Space + KEY_APOSTROPHE = 39 # Key: ' + KEY_COMMA = 44 # Key: , + KEY_MINUS = 45 # Key: - + KEY_PERIOD = 46 # Key: . + KEY_SLASH = 47 # Key: / + KEY_ZERO = 48 # Key: 0 + KEY_ONE = 49 # Key: 1 + KEY_TWO = 50 # Key: 2 + KEY_THREE = 51 # Key: 3 + KEY_FOUR = 52 # Key: 4 + KEY_FIVE = 53 # Key: 5 + KEY_SIX = 54 # Key: 6 + KEY_SEVEN = 55 # Key: 7 + KEY_EIGHT = 56 # Key: 8 + KEY_NINE = 57 # Key: 9 + KEY_SEMICOLON = 59 # Key: ; + KEY_EQUAL = 61 # Key: = + KEY_A = 65 # Key: A | a + KEY_B = 66 # Key: B | b + KEY_C = 67 # Key: C | c + KEY_D = 68 # Key: D | d + KEY_E = 69 # Key: E | e + KEY_F = 70 # Key: F | f + KEY_G = 71 # Key: G | g + KEY_H = 72 # Key: H | h + KEY_I = 73 # Key: I | i + KEY_J = 74 # Key: J | j + KEY_K = 75 # Key: K | k + KEY_L = 76 # Key: L | l + KEY_M = 77 # Key: M | m + KEY_N = 78 # Key: N | n + KEY_O = 79 # Key: O | o + KEY_P = 80 # Key: P | p + KEY_Q = 81 # Key: Q | q + KEY_R = 82 # Key: R | r + KEY_S = 83 # Key: S | s + KEY_T = 84 # Key: T | t + KEY_U = 85 # Key: U | u + KEY_V = 86 # Key: V | v + KEY_W = 87 # Key: W | w + KEY_X = 88 # Key: X | x + KEY_Y = 89 # Key: Y | y + KEY_Z = 90 # Key: Z | z + KEY_LEFT_BRACKET = 91 # Key: [ + KEY_BACKSLASH = 92 # Key: '\' + KEY_RIGHT_BRACKET = 93 # Key: ] + KEY_GRAVE = 96 # Key: ` + KEY_ESCAPE = 256 # Key: Esc + KEY_ENTER = 257 # Key: Enter + KEY_TAB = 258 # Key: Tab + KEY_BACKSPACE = 259 # Key: Backspace + KEY_INSERT = 260 # Key: Ins + KEY_DELETE = 261 # Key: Del + KEY_RIGHT = 262 # Key: Cursor right + KEY_LEFT = 263 # Key: Cursor left + KEY_DOWN = 264 # Key: Cursor down + KEY_UP = 265 # Key: Cursor up + KEY_PAGE_UP = 266 # Key: Page up + KEY_PAGE_DOWN = 267 # Key: Page down + KEY_HOME = 268 # Key: Home + KEY_END = 269 # Key: End + KEY_CAPS_LOCK = 280 # Key: Caps lock + KEY_SCROLL_LOCK = 281 # Key: Scroll down + KEY_NUM_LOCK = 282 # Key: Num lock + KEY_PRINT_SCREEN = 283 # Key: Print screen + KEY_PAUSE = 284 # Key: Pause + KEY_F1 = 290 # Key: F1 + KEY_F2 = 291 # Key: F2 + KEY_F3 = 292 # Key: F3 + KEY_F4 = 293 # Key: F4 + KEY_F5 = 294 # Key: F5 + KEY_F6 = 295 # Key: F6 + KEY_F7 = 296 # Key: F7 + KEY_F8 = 297 # Key: F8 + KEY_F9 = 298 # Key: F9 + KEY_F10 = 299 # Key: F10 + KEY_F11 = 300 # Key: F11 + KEY_F12 = 301 # Key: F12 + KEY_KP_0 = 320 # Key: Keypad 0 + KEY_KP_1 = 321 # Key: Keypad 1 + KEY_KP_2 = 322 # Key: Keypad 2 + KEY_KP_3 = 323 # Key: Keypad 3 + KEY_KP_4 = 324 # Key: Keypad 4 + KEY_KP_5 = 325 # Key: Keypad 5 + KEY_KP_6 = 326 # Key: Keypad 6 + KEY_KP_7 = 327 # Key: Keypad 7 + KEY_KP_8 = 328 # Key: Keypad 8 + KEY_KP_9 = 329 # Key: Keypad 9 + KEY_KP_DECIMAL = 330 # Key: Keypad . + KEY_KP_DIVIDE = 331 # Key: Keypad / + KEY_KP_MULTIPLY = 332 # Key: Keypad * + KEY_KP_SUBTRACT = 333 # Key: Keypad - + KEY_KP_ADD = 334 # Key: Keypad + + KEY_KP_ENTER = 335 # Key: Keypad Enter + KEY_KP_EQUAL = 336 # Key: Keypad = + KEY_LEFT_SHIFT = 340 # Key: Shift left + KEY_LEFT_CONTROL = 341 # Key: Control left + KEY_LEFT_ALT = 342 # Key: Alt left + KEY_LEFT_SUPER = 343 # Key: Super left + KEY_RIGHT_SHIFT = 344 # Key: Shift right + KEY_RIGHT_CONTROL = 345 # Key: Control right + KEY_RIGHT_ALT = 346 # Key: Alt right + KEY_RIGHT_SUPER = 347 # Key: Super right + KEY_KB_MENU = 348 # Key: KB menu +converter KeyboardKey2int32* (self: KeyboardKey): int32 = self.int32 +# Add backwards compatibility support for deprecated names +template MOUSE_LEFT_BUTTON*(): auto = MOUSE_BUTTON_LEFT +template MOUSE_RIGHT_BUTTON*(): auto = MOUSE_BUTTON_RIGHT +template MOUSE_MIDDLE_BUTTON*(): auto = MOUSE_BUTTON_MIDDLE +# Mouse buttons +type MouseButton* = enum + MOUSE_BUTTON_LEFT = 0 # Mouse button left + MOUSE_BUTTON_RIGHT = 1 # Mouse button right + MOUSE_BUTTON_MIDDLE = 2 # Mouse button middle (pressed wheel) + MOUSE_BUTTON_SIDE = 3 # Mouse button side (advanced mouse device) + MOUSE_BUTTON_EXTRA = 4 # Mouse button extra (advanced mouse device) + MOUSE_BUTTON_FORWARD = 5 # Mouse button fordward (advanced mouse device) + MOUSE_BUTTON_BACK = 6 # Mouse button back (advanced mouse device) +converter MouseButton2int32* (self: MouseButton): int32 = self.int32 +# Mouse cursor +type MouseCursor* = enum + MOUSE_CURSOR_DEFAULT = 0 # Default pointer shape + MOUSE_CURSOR_ARROW = 1 # Arrow shape + MOUSE_CURSOR_IBEAM = 2 # Text writing cursor shape + MOUSE_CURSOR_CROSSHAIR = 3 # Cross shape + MOUSE_CURSOR_POINTING_HAND = 4 # Pointing hand cursor + MOUSE_CURSOR_RESIZE_EW = 5 # Horizontal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NS = 6 # Vertical resize/move arrow shape + MOUSE_CURSOR_RESIZE_NWSE = 7 # Top-left to bottom-right diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_NESW = 8 # The top-right to bottom-left diagonal resize/move arrow shape + MOUSE_CURSOR_RESIZE_ALL = 9 # The omni-directional resize/move cursor shape + MOUSE_CURSOR_NOT_ALLOWED = 10 # The operation-not-allowed shape +converter MouseCursor2int32* (self: MouseCursor): int32 = self.int32 +# Gamepad buttons +type GamepadButton* = enum + GAMEPAD_BUTTON_UNKNOWN = 0 # Unknown button, just for error checking + GAMEPAD_BUTTON_LEFT_FACE_UP # Gamepad left DPAD up button + GAMEPAD_BUTTON_LEFT_FACE_RIGHT # Gamepad left DPAD right button + GAMEPAD_BUTTON_LEFT_FACE_DOWN # Gamepad left DPAD down button + GAMEPAD_BUTTON_LEFT_FACE_LEFT # Gamepad left DPAD left button + GAMEPAD_BUTTON_RIGHT_FACE_UP # Gamepad right button up (i.e. PS3: Triangle, Xbox: Y) + GAMEPAD_BUTTON_RIGHT_FACE_RIGHT # Gamepad right button right (i.e. PS3: Square, Xbox: X) + GAMEPAD_BUTTON_RIGHT_FACE_DOWN # Gamepad right button down (i.e. PS3: Cross, Xbox: A) + GAMEPAD_BUTTON_RIGHT_FACE_LEFT # Gamepad right button left (i.e. PS3: Circle, Xbox: B) + GAMEPAD_BUTTON_LEFT_TRIGGER_1 # Gamepad top/back trigger left (first), it could be a trailing button + GAMEPAD_BUTTON_LEFT_TRIGGER_2 # Gamepad top/back trigger left (second), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_1 # Gamepad top/back trigger right (one), it could be a trailing button + GAMEPAD_BUTTON_RIGHT_TRIGGER_2 # Gamepad top/back trigger right (second), it could be a trailing button + GAMEPAD_BUTTON_MIDDLE_LEFT # Gamepad center buttons, left one (i.e. PS3: Select) + GAMEPAD_BUTTON_MIDDLE # Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX) + GAMEPAD_BUTTON_MIDDLE_RIGHT # Gamepad center buttons, right one (i.e. PS3: Start) + GAMEPAD_BUTTON_LEFT_THUMB # Gamepad joystick pressed button left + GAMEPAD_BUTTON_RIGHT_THUMB # Gamepad joystick pressed button right +converter GamepadButton2int32* (self: GamepadButton): int32 = self.int32 +# Gamepad axis +type GamepadAxis* = enum + GAMEPAD_AXIS_LEFT_X = 0 # Gamepad left stick X axis + GAMEPAD_AXIS_LEFT_Y = 1 # Gamepad left stick Y axis + GAMEPAD_AXIS_RIGHT_X = 2 # Gamepad right stick X axis + GAMEPAD_AXIS_RIGHT_Y = 3 # Gamepad right stick Y axis + GAMEPAD_AXIS_LEFT_TRIGGER = 4 # Gamepad back trigger left, pressure level: [1..-1] + GAMEPAD_AXIS_RIGHT_TRIGGER = 5 # Gamepad back trigger right, pressure level: [1..-1] +converter GamepadAxis2int32* (self: GamepadAxis): int32 = self.int32 +# Material map index +type MaterialMapIndex* = enum + MATERIAL_MAP_ALBEDO = 0 # Albedo material (same as: MATERIAL_MAP_DIFFUSE) + MATERIAL_MAP_METALNESS # Metalness material (same as: MATERIAL_MAP_SPECULAR) + MATERIAL_MAP_NORMAL # Normal material + MATERIAL_MAP_ROUGHNESS # Roughness material + MATERIAL_MAP_OCCLUSION # Ambient occlusion material + MATERIAL_MAP_EMISSION # Emission material + MATERIAL_MAP_HEIGHT # Heightmap material + MATERIAL_MAP_CUBEMAP # Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_IRRADIANCE # Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_PREFILTER # Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP) + MATERIAL_MAP_BRDG # Brdg material +converter MaterialMapIndex2int32* (self: MaterialMapIndex): int32 = self.int32 +template MATERIAL_MAP_DIFFUSE*(): auto = MATERIAL_MAP_ALBEDO +template MATERIAL_MAP_SPECULAR*(): auto = MATERIAL_MAP_METALNESS +# Shader location index +type ShaderLocationIndex* = enum + SHADER_LOC_VERTEX_POSITION = 0 # Shader location: vertex attribute: position + SHADER_LOC_VERTEX_TEXCOORD01 # Shader location: vertex attribute: texcoord01 + SHADER_LOC_VERTEX_TEXCOORD02 # Shader location: vertex attribute: texcoord02 + SHADER_LOC_VERTEX_NORMAL # Shader location: vertex attribute: normal + SHADER_LOC_VERTEX_TANGENT # Shader location: vertex attribute: tangent + SHADER_LOC_VERTEX_COLOR # Shader location: vertex attribute: color + SHADER_LOC_MATRIX_MVP # Shader location: matrix uniform: model-view-projection + SHADER_LOC_MATRIX_VIEW # Shader location: matrix uniform: view (camera transform) + SHADER_LOC_MATRIX_PROJECTION # Shader location: matrix uniform: projection + SHADER_LOC_MATRIX_MODEL # Shader location: matrix uniform: model (transform) + SHADER_LOC_MATRIX_NORMAL # Shader location: matrix uniform: normal + SHADER_LOC_VECTOR_VIEW # Shader location: vector uniform: view + SHADER_LOC_COLOR_DIFFUSE # Shader location: vector uniform: diffuse color + SHADER_LOC_COLOR_SPECULAR # Shader location: vector uniform: specular color + SHADER_LOC_COLOR_AMBIENT # Shader location: vector uniform: ambient color + SHADER_LOC_MAP_ALBEDO # Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE) + SHADER_LOC_MAP_METALNESS # Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR) + SHADER_LOC_MAP_NORMAL # Shader location: sampler2d texture: normal + SHADER_LOC_MAP_ROUGHNESS # Shader location: sampler2d texture: roughness + SHADER_LOC_MAP_OCCLUSION # Shader location: sampler2d texture: occlusion + SHADER_LOC_MAP_EMISSION # Shader location: sampler2d texture: emission + SHADER_LOC_MAP_HEIGHT # Shader location: sampler2d texture: height + SHADER_LOC_MAP_CUBEMAP # Shader location: samplerCube texture: cubemap + SHADER_LOC_MAP_IRRADIANCE # Shader location: samplerCube texture: irradiance + SHADER_LOC_MAP_PREFILTER # Shader location: samplerCube texture: prefilter + SHADER_LOC_MAP_BRDF # Shader location: sampler2d texture: brdf +converter ShaderLocationIndex2int32* (self: ShaderLocationIndex): int32 = self.int32 +template SHADER_LOC_MAP_DIFFUSE*(): auto = SHADER_LOC_MAP_ALBEDO +template SHADER_LOC_MAP_SPECULAR*(): auto = SHADER_LOC_MAP_METALNESS +# Shader uniform data type +type ShaderUniformDataType* = enum + SHADER_UNIFORM_FLOAT = 0 # Shader uniform type: float + SHADER_UNIFORM_VEC2 # Shader uniform type: vec2 (2 float) + SHADER_UNIFORM_VEC3 # Shader uniform type: vec3 (3 float) + SHADER_UNIFORM_VEC4 # Shader uniform type: vec4 (4 float) + SHADER_UNIFORM_INT # Shader uniform type: int + SHADER_UNIFORM_IVEC2 # Shader uniform type: ivec2 (2 int) + SHADER_UNIFORM_IVEC3 # Shader uniform type: ivec3 (3 int) + SHADER_UNIFORM_IVEC4 # Shader uniform type: ivec4 (4 int) + SHADER_UNIFORM_SAMPLER2D # Shader uniform type: sampler2d +converter ShaderUniformDataType2int32* (self: ShaderUniformDataType): int32 = self.int32 +# Shader attribute data types +type ShaderAttributeDataType* = enum + SHADER_ATTRIB_FLOAT = 0 # Shader attribute type: float + SHADER_ATTRIB_VEC2 # Shader attribute type: vec2 (2 float) + SHADER_ATTRIB_VEC3 # Shader attribute type: vec3 (3 float) + SHADER_ATTRIB_VEC4 # Shader attribute type: vec4 (4 float) +converter ShaderAttributeDataType2int32* (self: ShaderAttributeDataType): int32 = self.int32 +# Pixel formats +# NOTE: Support depends on OpenGL version and platform +type PixelFormat* = enum + PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1 # 8 bit per pixel (no alpha) + PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA # 8*2 bpp (2 channels) + PIXELFORMAT_UNCOMPRESSED_R5G6B5 # 16 bpp + PIXELFORMAT_UNCOMPRESSED_R8G8B8 # 24 bpp + PIXELFORMAT_UNCOMPRESSED_R5G5B5A1 # 16 bpp (1 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R4G4B4A4 # 16 bpp (4 bit alpha) + PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 # 32 bpp + PIXELFORMAT_UNCOMPRESSED_R32 # 32 bpp (1 channel - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32 # 32*3 bpp (3 channels - float) + PIXELFORMAT_UNCOMPRESSED_R32G32B32A32 # 32*4 bpp (4 channels - float) + PIXELFORMAT_COMPRESSED_DXT1_RGB # 4 bpp (no alpha) + PIXELFORMAT_COMPRESSED_DXT1_RGBA # 4 bpp (1 bit alpha) + PIXELFORMAT_COMPRESSED_DXT3_RGBA # 8 bpp + PIXELFORMAT_COMPRESSED_DXT5_RGBA # 8 bpp + PIXELFORMAT_COMPRESSED_ETC1_RGB # 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_RGB # 4 bpp + PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA # 8 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGB # 4 bpp + PIXELFORMAT_COMPRESSED_PVRT_RGBA # 4 bpp + PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA # 8 bpp + PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA # 2 bpp +converter PixelFormat2int32* (self: PixelFormat): int32 = self.int32 +# Texture parameters: filter mode +# NOTE 1: Filtering considers mipmaps if available in the texture +# NOTE 2: Filter is accordingly set for minification and magnification +type TextureFilter* = enum + TEXTURE_FILTER_POINT = 0 # No filter, just pixel aproximation + TEXTURE_FILTER_BILINEAR # Linear filtering + TEXTURE_FILTER_TRILINEAR # Trilinear filtering (linear with mipmaps) + TEXTURE_FILTER_ANISOTROPIC_4X # Anisotropic filtering 4x + TEXTURE_FILTER_ANISOTROPIC_8X # Anisotropic filtering 8x + TEXTURE_FILTER_ANISOTROPIC_16X # Anisotropic filtering 16x +converter TextureFilter2int32* (self: TextureFilter): int32 = self.int32 +# Texture parameters: wrap mode +type TextureWrap* = enum + TEXTURE_WRAP_REPEAT = 0 # Repeats texture in tiled mode + TEXTURE_WRAP_CLAMP # Clamps texture to edge pixel in tiled mode + TEXTURE_WRAP_MIRROR_REPEAT # Mirrors and repeats the texture in tiled mode + TEXTURE_WRAP_MIRROR_CLAMP # Mirrors and clamps to border the texture in tiled mode +converter TextureWrap2int32* (self: TextureWrap): int32 = self.int32 +# Cubemap layouts +type CubemapLayout* = enum + CUBEMAP_LAYOUT_AUTO_DETECT = 0 # Automatically detect layout type + CUBEMAP_LAYOUT_LINE_VERTICAL # Layout is defined by a vertical line with faces + CUBEMAP_LAYOUT_LINE_HORIZONTAL # Layout is defined by an horizontal line with faces + CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR # Layout is defined by a 3x4 cross with cubemap faces + CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE # Layout is defined by a 4x3 cross with cubemap faces + CUBEMAP_LAYOUT_PANORAMA # Layout is defined by a panorama image (equirectangular map) +converter CubemapLayout2int32* (self: CubemapLayout): int32 = self.int32 +# Font type, defines generation method +type FontType* = enum + FONT_DEFAULT = 0 # Default font generation, anti-aliased + FONT_BITMAP # Bitmap font generation, no anti-aliasing + FONT_SDF # SDF font generation, requires external shader +converter FontType2int32* (self: FontType): int32 = self.int32 +# Color blending modes (pre-defined) +type BlendMode* = enum + BLEND_ALPHA = 0 # Blend textures considering alpha (default) + BLEND_ADDITIVE # Blend textures adding colors + BLEND_MULTIPLIED # Blend textures multiplying colors + BLEND_ADD_COLORS # Blend textures adding colors (alternative) + BLEND_SUBTRACT_COLORS # Blend textures subtracting colors (alternative) + BLEND_CUSTOM # Belnd textures using custom src/dst factors (use rlSetBlendMode()) +converter BlendMode2int32* (self: BlendMode): int32 = self.int32 +# Gestures +# NOTE: It could be used as flags to enable only some gestures +type Gesture* = enum + GESTURE_NONE = 0 # No gesture + GESTURE_TAP = 1 # Tap gesture + GESTURE_DOUBLETAP = 2 # Double tap gesture + GESTURE_HOLD = 4 # Hold gesture + GESTURE_DRAG = 8 # Drag gesture + GESTURE_SWIPE_RIGHT = 16 # Swipe right gesture + GESTURE_SWIPE_LEFT = 32 # Swipe left gesture + GESTURE_SWIPE_UP = 64 # Swipe up gesture + GESTURE_SWIPE_DOWN = 128 # Swipe down gesture + GESTURE_PINCH_IN = 256 # Pinch in gesture + GESTURE_PINCH_OUT = 512 # Pinch out gesture +converter Gesture2int32* (self: Gesture): int32 = self.int32 +# Camera system modes +type CameraMode* = enum + CAMERA_CUSTOM = 0 # Custom camera + CAMERA_FREE # Free camera + CAMERA_ORBITAL # Orbital camera + CAMERA_FIRST_PERSON # First person camera + CAMERA_THIRD_PERSON # Third person camera +converter CameraMode2int32* (self: CameraMode): int32 = self.int32 +# Camera projection +type CameraProjection* = enum + CAMERA_PERSPECTIVE = 0 # Perspective projection + CAMERA_ORTHOGRAPHIC # Orthographic projection +converter CameraProjection2int32* (self: CameraProjection): int32 = self.int32 +# N-patch layout +type NPatchLayout* = enum + NPATCH_NINE_PATCH = 0 # Npatch layout: 3x3 tiles + NPATCH_THREE_PATCH_VERTICAL # Npatch layout: 1x3 tiles + NPATCH_THREE_PATCH_HORIZONTAL # Npatch layout: 3x1 tiles +converter NPatchLayout2int32* (self: NPatchLayout): int32 = self.int32 +# Callbacks to hook some internal functions +# WARNING: This callbacks are intended for advance users +type TraceLogCallback* = proc() +type LoadFileDataCallback* = proc(): uint8 +type SaveFileDataCallback* = proc(): bool +type LoadFileTextCallback* = proc(): char +type SaveFileTextCallback* = proc(): bool +# ------------------------------------------------------------------------------------ +# Global Variables Definition +# ------------------------------------------------------------------------------------ +# It's lonely here... +# ------------------------------------------------------------------------------------ +# Window and Graphics Device Functions (Module: core) +# ------------------------------------------------------------------------------------ +# Window-related functions +proc InitWindow*(width: int32; height: int32; title: cstring) {.RLAPI, importc: "InitWindow".} # Initialize window and OpenGL context +proc WindowShouldClose*(): bool {.RLAPI, importc: "WindowShouldClose".} # Check if KEY_ESCAPE pressed or Close icon pressed +proc CloseWindow*() {.RLAPI, importc: "CloseWindow".} # Close window and unload OpenGL context +proc IsWindowReady*(): bool {.RLAPI, importc: "IsWindowReady".} # Check if window has been initialized successfully +proc IsWindowFullscreen*(): bool {.RLAPI, importc: "IsWindowFullscreen".} # Check if window is currently fullscreen +proc IsWindowHidden*(): bool {.RLAPI, importc: "IsWindowHidden".} # Check if window is currently hidden (only PLATFORM_DESKTOP) +proc IsWindowMinimized*(): bool {.RLAPI, importc: "IsWindowMinimized".} # Check if window is currently minimized (only PLATFORM_DESKTOP) +proc IsWindowMaximized*(): bool {.RLAPI, importc: "IsWindowMaximized".} # Check if window is currently maximized (only PLATFORM_DESKTOP) +proc IsWindowFocused*(): bool {.RLAPI, importc: "IsWindowFocused".} # Check if window is currently focused (only PLATFORM_DESKTOP) +proc IsWindowResized*(): bool {.RLAPI, importc: "IsWindowResized".} # Check if window has been resized last frame +proc IsWindowState*(flag: uint32): bool {.RLAPI, importc: "IsWindowState".} # Check if one specific window flag is enabled +proc SetWindowState*(flags: uint32) {.RLAPI, importc: "SetWindowState".} # Set window configuration state using flags +proc ClearWindowState*(flags: uint32) {.RLAPI, importc: "ClearWindowState".} # Clear window configuration state flags +proc ToggleFullscreen*() {.RLAPI, importc: "ToggleFullscreen".} # Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP) +proc MaximizeWindow*() {.RLAPI, importc: "MaximizeWindow".} # Set window state: maximized, if resizable (only PLATFORM_DESKTOP) +proc MinimizeWindow*() {.RLAPI, importc: "MinimizeWindow".} # Set window state: minimized, if resizable (only PLATFORM_DESKTOP) +proc RestoreWindow*() {.RLAPI, importc: "RestoreWindow".} # Set window state: not minimized/maximized (only PLATFORM_DESKTOP) +proc SetWindowIcon*(image: Image) {.RLAPI, importc: "SetWindowIcon".} # Set icon for window (only PLATFORM_DESKTOP) +proc SetWindowTitle*(title: cstring) {.RLAPI, importc: "SetWindowTitle".} # Set title for window (only PLATFORM_DESKTOP) +proc SetWindowPosition*(x: int32; y: int32) {.RLAPI, importc: "SetWindowPosition".} # Set window position on screen (only PLATFORM_DESKTOP) +proc SetWindowMonitor*(monitor: int32) {.RLAPI, importc: "SetWindowMonitor".} # Set monitor for the current window (fullscreen mode) +proc SetWindowMinSize*(width: int32; height: int32) {.RLAPI, importc: "SetWindowMinSize".} # Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE) +proc SetWindowSize*(width: int32; height: int32) {.RLAPI, importc: "SetWindowSize".} # Set window dimensions +proc GetWindowHandle*(): pointer {.RLAPI, importc: "GetWindowHandle".} # Get native window handle +proc GetScreenWidth*(): int32 {.RLAPI, importc: "GetScreenWidth".} # Get current screen width +proc GetScreenHeight*(): int32 {.RLAPI, importc: "GetScreenHeight".} # Get current screen height +proc GetMonitorCount*(): int32 {.RLAPI, importc: "GetMonitorCount".} # Get number of connected monitors +proc GetCurrentMonitor*(): int32 {.RLAPI, importc: "GetCurrentMonitor".} # Get current connected monitor +proc GetMonitorPosition*(monitor: int32): Vector2 {.RLAPI, importc: "GetMonitorPosition".} # Get specified monitor position +proc GetMonitorWidth*(monitor: int32): int32 {.RLAPI, importc: "GetMonitorWidth".} # Get specified monitor width (max available by monitor) +proc GetMonitorHeight*(monitor: int32): int32 {.RLAPI, importc: "GetMonitorHeight".} # Get specified monitor height (max available by monitor) +proc GetMonitorPhysicalWidth*(monitor: int32): int32 {.RLAPI, importc: "GetMonitorPhysicalWidth".} # Get specified monitor physical width in millimetres +proc GetMonitorPhysicalHeight*(monitor: int32): int32 {.RLAPI, importc: "GetMonitorPhysicalHeight".} # Get specified monitor physical height in millimetres +proc GetMonitorRefreshRate*(monitor: int32): int32 {.RLAPI, importc: "GetMonitorRefreshRate".} # Get specified monitor refresh rate +proc GetWindowPosition*(): Vector2 {.RLAPI, importc: "GetWindowPosition".} # Get window position XY on monitor +proc GetWindowScaleDPI*(): Vector2 {.RLAPI, importc: "GetWindowScaleDPI".} # Get window scale DPI factor +proc GetMonitorName*(monitor: int32): cstring {.RLAPI, importc: "GetMonitorName".} # Get the human-readable, UTF-8 encoded name of the primary monitor +proc SetClipboardText*(text: cstring) {.RLAPI, importc: "SetClipboardText".} # Set clipboard text content +proc GetClipboardText*(): cstring {.RLAPI, importc: "GetClipboardText".} # Get clipboard text content +# Custom frame control functions +# NOTE: Those functions are intended for advance users that want full control over the frame processing +# By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timming + PollInputEvents() +# To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL +proc SwapScreenBuffer*() {.RLAPI, importc: "SwapScreenBuffer".} # Swap back buffer with front buffer (screen drawing) +proc PollInputEvents*() {.RLAPI, importc: "PollInputEvents".} # Register all input events +proc WaitTime*(ms: float32) {.RLAPI, importc: "WaitTime".} # Wait for some milliseconds (halt program execution) +# Cursor-related functions +proc ShowCursor*() {.RLAPI, importc: "ShowCursor".} # Shows cursor +proc HideCursor*() {.RLAPI, importc: "HideCursor".} # Hides cursor +proc IsCursorHidden*(): bool {.RLAPI, importc: "IsCursorHidden".} # Check if cursor is not visible +proc EnableCursor*() {.RLAPI, importc: "EnableCursor".} # Enables cursor (unlock cursor) +proc DisableCursor*() {.RLAPI, importc: "DisableCursor".} # Disables cursor (lock cursor) +proc IsCursorOnScreen*(): bool {.RLAPI, importc: "IsCursorOnScreen".} # Check if cursor is on the screen +# Drawing-related functions +proc ClearBackground*(color: Color) {.RLAPI, importc: "ClearBackground".} # Set background color (framebuffer clear color) +proc BeginDrawing*() {.RLAPI, importc: "BeginDrawing".} # Setup canvas (framebuffer) to start drawing +proc EndDrawing*() {.RLAPI, importc: "EndDrawing".} # End canvas drawing and swap buffers (double buffering) +proc BeginMode2D*(camera: Camera2D) {.RLAPI, importc: "BeginMode2D".} # Begin 2D mode with custom camera (2D) +proc EndMode2D*() {.RLAPI, importc: "EndMode2D".} # Ends 2D mode with custom camera +proc BeginMode3D*(camera: Camera3D) {.RLAPI, importc: "BeginMode3D".} # Begin 3D mode with custom camera (3D) +proc EndMode3D*() {.RLAPI, importc: "EndMode3D".} # Ends 3D mode and returns to default 2D orthographic mode +proc BeginTextureMode*(target: RenderTexture2D) {.RLAPI, importc: "BeginTextureMode".} # Begin drawing to render texture +proc EndTextureMode*() {.RLAPI, importc: "EndTextureMode".} # Ends drawing to render texture +proc BeginShaderMode*(shader: Shader) {.RLAPI, importc: "BeginShaderMode".} # Begin custom shader drawing +proc EndShaderMode*() {.RLAPI, importc: "EndShaderMode".} # End custom shader drawing (use default shader) +proc BeginBlendMode*(mode: int32) {.RLAPI, importc: "BeginBlendMode".} # Begin blending mode (alpha, additive, multiplied, subtract, custom) +proc EndBlendMode*() {.RLAPI, importc: "EndBlendMode".} # End blending mode (reset to default: alpha blending) +proc BeginScissorMode*(x: int32; y: int32; width: int32; height: int32) {.RLAPI, importc: "BeginScissorMode".} # Begin scissor mode (define screen area for following drawing) +proc EndScissorMode*() {.RLAPI, importc: "EndScissorMode".} # End scissor mode +proc BeginVrStereoMode*(config: VrStereoConfig) {.RLAPI, importc: "BeginVrStereoMode".} # Begin stereo rendering (requires VR simulator) +proc EndVrStereoMode*() {.RLAPI, importc: "EndVrStereoMode".} # End stereo rendering (requires VR simulator) +# VR stereo config functions for VR simulator +proc LoadVrStereoConfig*(device: VrDeviceInfo): VrStereoConfig {.RLAPI, importc: "LoadVrStereoConfig".} # Load VR stereo config for VR simulator device parameters +proc UnloadVrStereoConfig*(config: VrStereoConfig) {.RLAPI, importc: "UnloadVrStereoConfig".} # Unload VR stereo config +# Shader management functions +# NOTE: Shader functionality is not available on OpenGL 1.1 +proc LoadShader*(vsFileName: cstring; fsFileName: cstring): Shader {.RLAPI, importc: "LoadShader".} # Load shader from files and bind default locations +proc LoadShaderFromMemory*(vsCode: cstring; fsCode: cstring): Shader {.RLAPI, importc: "LoadShaderFromMemory".} # Load shader from code strings and bind default locations +proc GetShaderLocation*(shader: Shader; uniformName: cstring): int32 {.RLAPI, importc: "GetShaderLocation".} # Get shader uniform location +proc GetShaderLocationAttrib*(shader: Shader; attribName: cstring): int32 {.RLAPI, importc: "GetShaderLocationAttrib".} # Get shader attribute location +proc SetShaderValue*(shader: Shader; locIndex: int32; value: pointer; uniformType: int32) {.RLAPI, importc: "SetShaderValue".} # Set shader uniform value +proc SetShaderValueV*(shader: Shader; locIndex: int32; value: pointer; uniformType: int32; count: int32) {.RLAPI, importc: "SetShaderValueV".} # Set shader uniform value vector +proc SetShaderValueMatrix*(shader: Shader; locIndex: int32; mat: Matrix) {.RLAPI, importc: "SetShaderValueMatrix".} # Set shader uniform value (matrix 4x4) +proc SetShaderValueTexture*(shader: Shader; locIndex: int32; texture: Texture2D) {.RLAPI, importc: "SetShaderValueTexture".} # Set shader uniform value for texture (sampler2d) +proc UnloadShader*(shader: Shader) {.RLAPI, importc: "UnloadShader".} # Unload shader from GPU memory (VRAM) +# Screen-space-related functions +proc GetMouseRay*(mousePosition: Vector2; camera: Camera): Ray {.RLAPI, importc: "GetMouseRay".} # Get a ray trace from mouse position +proc GetCameraMatrix*(camera: Camera): Matrix {.RLAPI, importc: "GetCameraMatrix".} # Get camera transform matrix (view matrix) +proc GetCameraMatrix2D*(camera: Camera2D): Matrix {.RLAPI, importc: "GetCameraMatrix2D".} # Get camera 2d transform matrix +proc GetWorldToScreen*(position: Vector3; camera: Camera): Vector2 {.RLAPI, importc: "GetWorldToScreen".} # Get the screen space position for a 3d world space position +proc GetWorldToScreenEx*(position: Vector3; camera: Camera; width: int32; height: int32): Vector2 {.RLAPI, importc: "GetWorldToScreenEx".} # Get size position for a 3d world space position +proc GetWorldToScreen2D*(position: Vector2; camera: Camera2D): Vector2 {.RLAPI, importc: "GetWorldToScreen2D".} # Get the screen space position for a 2d camera world space position +proc GetScreenToWorld2D*(position: Vector2; camera: Camera2D): Vector2 {.RLAPI, importc: "GetScreenToWorld2D".} # Get the world space position for a 2d camera screen space position +# Timing-related functions +proc SetTargetFPS*(fps: int32) {.RLAPI, importc: "SetTargetFPS".} # Set target FPS (maximum) +proc GetFPS*(): int32 {.RLAPI, importc: "GetFPS".} # Get current FPS +proc GetFrameTime*(): float32 {.RLAPI, importc: "GetFrameTime".} # Get time in seconds for last frame drawn (delta time) +proc GetTime*(): float64 {.RLAPI, importc: "GetTime".} # Get elapsed time in seconds since InitWindow() +# Misc. functions +proc GetRandomValue*(min: int32; max: int32): int32 {.RLAPI, importc: "GetRandomValue".} # Get a random value between min and max (both included) +proc TakeScreenshot*(fileName: cstring) {.RLAPI, importc: "TakeScreenshot".} # Takes a screenshot of current screen (filename extension defines format) +proc SetConfigFlags*(flags: uint32) {.RLAPI, importc: "SetConfigFlags".} # Setup init configuration flags (view FLAGS) +proc TraceLog*(logLevel: int32; text: cstring) {.RLAPI, varargs, importc: "TraceLog".} # Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...) +proc SetTraceLogLevel*(logLevel: int32) {.RLAPI, importc: "SetTraceLogLevel".} # Set the current threshold (minimum) log level +proc MemAlloc*(size: int32): pointer {.RLAPI, importc: "MemAlloc".} # Internal memory allocator +proc MemRealloc*(ptrx: pointer; size: int32): pointer {.RLAPI, importc: "MemRealloc".} # Internal memory reallocator +proc MemFree*(ptrx: pointer) {.RLAPI, importc: "MemFree".} # Internal memory free +# Set custom callbacks +# WARNING: Callbacks setup is intended for advance users +proc SetTraceLogCallback*(callback: TraceLogCallback) {.RLAPI, importc: "SetTraceLogCallback".} # Set custom trace log +proc SetLoadFileDataCallback*(callback: LoadFileDataCallback) {.RLAPI, importc: "SetLoadFileDataCallback".} # Set custom file binary data loader +proc SetSaveFileDataCallback*(callback: SaveFileDataCallback) {.RLAPI, importc: "SetSaveFileDataCallback".} # Set custom file binary data saver +proc SetLoadFileTextCallback*(callback: LoadFileTextCallback) {.RLAPI, importc: "SetLoadFileTextCallback".} # Set custom file text data loader +proc SetSaveFileTextCallback*(callback: SaveFileTextCallback) {.RLAPI, importc: "SetSaveFileTextCallback".} # Set custom file text data saver +# Files management functions +proc LoadFileData*(fileName: cstring; bytesRead: uint32): uint8 {.RLAPI, importc: "LoadFileData".} # Load file data as byte array (read) +proc UnloadFileData*(data: uint8) {.RLAPI, importc: "UnloadFileData".} # Unload file data allocated by LoadFileData() +proc SaveFileData*(fileName: cstring; data: pointer; bytesToWrite: uint32): bool {.RLAPI, importc: "SaveFileData".} # Save data to file from byte array (write), returns true on success +proc LoadFileText*(fileName: cstring): ptr char {.RLAPI, importc: "LoadFileText".} # Load text data from file (read), returns a '\0' terminated string +proc UnloadFileText*(text: ptr char) {.RLAPI, importc: "UnloadFileText".} # Unload file text data allocated by LoadFileText() +proc SaveFileText*(fileName: cstring; text: ptr char): bool {.RLAPI, importc: "SaveFileText".} # Save text data to file (write), string must be '\0' terminated, returns true on success +proc FileExists*(fileName: cstring): bool {.RLAPI, importc: "FileExists".} # Check if file exists +proc DirectoryExists*(dirPath: cstring): bool {.RLAPI, importc: "DirectoryExists".} # Check if a directory path exists +proc IsFileExtension*(fileName: cstring; ext: cstring): bool {.RLAPI, importc: "IsFileExtension".} # Check file extension (including point: .png, .wav) +proc GetFileExtension*(fileName: cstring): cstring {.RLAPI, importc: "GetFileExtension".} # Get pointer to extension for a filename string (includes dot: '.png') +proc GetFileName*(filePath: cstring): cstring {.RLAPI, importc: "GetFileName".} # Get pointer to filename for a path string +proc GetFileNameWithoutExt*(filePath: cstring): cstring {.RLAPI, importc: "GetFileNameWithoutExt".} # Get filename string without extension (uses static string) +proc GetDirectoryPath*(filePath: cstring): cstring {.RLAPI, importc: "GetDirectoryPath".} # Get full path for a given fileName with path (uses static string) +proc GetPrevDirectoryPath*(dirPath: cstring): cstring {.RLAPI, importc: "GetPrevDirectoryPath".} # Get previous directory path for a given path (uses static string) +proc GetWorkingDirectory*(): cstring {.RLAPI, importc: "GetWorkingDirectory".} # Get current working directory (uses static string) +proc GetDirectoryFiles*(dirPath: cstring; count: pointer): cstringArray {.RLAPI, importc: "GetDirectoryFiles".} # Get filenames in a directory path (memory should be freed) +proc ClearDirectoryFiles*() {.RLAPI, importc: "ClearDirectoryFiles".} # Clear directory files paths buffers (free memory) +proc ChangeDirectory*(dir: cstring): bool {.RLAPI, importc: "ChangeDirectory".} # Change working directory, return true on success +proc IsFileDropped*(): bool {.RLAPI, importc: "IsFileDropped".} # Check if a file has been dropped into window +proc GetDroppedFiles*(count: pointer): cstringArray {.RLAPI, importc: "GetDroppedFiles".} # Get dropped files names (memory should be freed) +proc ClearDroppedFiles*() {.RLAPI, importc: "ClearDroppedFiles".} # Clear dropped files paths buffer (free memory) +proc GetFileModTime*(fileName: cstring): int32 {.RLAPI, importc: "GetFileModTime".} # Get file modification time (last write time) +proc CompressData*(data: uint8; dataLength: int32; compDataLength: pointer): uint8 {.RLAPI, importc: "CompressData".} # Compress data (DEFLATE algorithm) +proc DecompressData*(compData: uint8; compDataLength: int32; dataLength: pointer): uint8 {.RLAPI, importc: "DecompressData".} # Decompress data (DEFLATE algorithm) +# Persistent storage management +proc SaveStorageValue*(position: uint32; value: int32): bool {.RLAPI, importc: "SaveStorageValue".} # Save integer value to storage file (to defined position), returns true on success +proc LoadStorageValue*(position: uint32): int32 {.RLAPI, importc: "LoadStorageValue".} # Load integer value from storage file (from defined position) +proc OpenURL*(url: cstring) {.RLAPI, importc: "OpenURL".} # Open URL with default system browser (if available) +# ------------------------------------------------------------------------------------ +# Input Handling Functions (Module: core) +# ------------------------------------------------------------------------------------ +# Input-related functions: keyboard +proc IsKeyPressed*(key: int32): bool {.RLAPI, importc: "IsKeyPressed".} # Check if a key has been pressed once +proc IsKeyDown*(key: int32): bool {.RLAPI, importc: "IsKeyDown".} # Check if a key is being pressed +proc IsKeyReleased*(key: int32): bool {.RLAPI, importc: "IsKeyReleased".} # Check if a key has been released once +proc IsKeyUp*(key: int32): bool {.RLAPI, importc: "IsKeyUp".} # Check if a key is NOT being pressed +proc SetExitKey*(key: int32) {.RLAPI, importc: "SetExitKey".} # Set a custom key to exit program (default is ESC) +proc GetKeyPressed*(): int32 {.RLAPI, importc: "GetKeyPressed".} # Get key pressed (keycode), call it multiple times for keys queued +proc GetCharPressed*(): int32 {.RLAPI, importc: "GetCharPressed".} # Get char pressed (unicode), call it multiple times for chars queued +# Input-related functions: gamepads +proc IsGamepadAvailable*(gamepad: int32): bool {.RLAPI, importc: "IsGamepadAvailable".} # Check if a gamepad is available +proc IsGamepadName*(gamepad: int32; name: cstring): bool {.RLAPI, importc: "IsGamepadName".} # Check gamepad name (if available) +proc GetGamepadName*(gamepad: int32): cstring {.RLAPI, importc: "GetGamepadName".} # Get gamepad internal name id +proc IsGamepadButtonPressed*(gamepad: int32; button: int32): bool {.RLAPI, importc: "IsGamepadButtonPressed".} # Check if a gamepad button has been pressed once +proc IsGamepadButtonDown*(gamepad: int32; button: int32): bool {.RLAPI, importc: "IsGamepadButtonDown".} # Check if a gamepad button is being pressed +proc IsGamepadButtonReleased*(gamepad: int32; button: int32): bool {.RLAPI, importc: "IsGamepadButtonReleased".} # Check if a gamepad button has been released once +proc IsGamepadButtonUp*(gamepad: int32; button: int32): bool {.RLAPI, importc: "IsGamepadButtonUp".} # Check if a gamepad button is NOT being pressed +proc GetGamepadButtonPressed*(): int32 {.RLAPI, importc: "GetGamepadButtonPressed".} # Get the last gamepad button pressed +proc GetGamepadAxisCount*(gamepad: int32): int32 {.RLAPI, importc: "GetGamepadAxisCount".} # Get gamepad axis count for a gamepad +proc GetGamepadAxisMovement*(gamepad: int32; axis: int32): float32 {.RLAPI, importc: "GetGamepadAxisMovement".} # Get axis movement value for a gamepad axis +proc SetGamepadMappings*(mappings: cstring): int32 {.RLAPI, importc: "SetGamepadMappings".} # Set internal gamepad mappings (SDL_GameControllerDB) +# Input-related functions: mouse +proc IsMouseButtonPressed*(button: int32): bool {.RLAPI, importc: "IsMouseButtonPressed".} # Check if a mouse button has been pressed once +proc IsMouseButtonDown*(button: int32): bool {.RLAPI, importc: "IsMouseButtonDown".} # Check if a mouse button is being pressed +proc IsMouseButtonReleased*(button: int32): bool {.RLAPI, importc: "IsMouseButtonReleased".} # Check if a mouse button has been released once +proc IsMouseButtonUp*(button: int32): bool {.RLAPI, importc: "IsMouseButtonUp".} # Check if a mouse button is NOT being pressed +proc GetMouseX*(): int32 {.RLAPI, importc: "GetMouseX".} # Get mouse position X +proc GetMouseY*(): int32 {.RLAPI, importc: "GetMouseY".} # Get mouse position Y +proc GetMousePosition*(): Vector2 {.RLAPI, importc: "GetMousePosition".} # Get mouse position XY +proc GetMouseDelta*(): Vector2 {.RLAPI, importc: "GetMouseDelta".} # Get mouse delta between frames +proc SetMousePosition*(x: int32; y: int32) {.RLAPI, importc: "SetMousePosition".} # Set mouse position XY +proc SetMouseOffset*(offsetX: int32; offsetY: int32) {.RLAPI, importc: "SetMouseOffset".} # Set mouse offset +proc SetMouseScale*(scaleX: float32; scaleY: float32) {.RLAPI, importc: "SetMouseScale".} # Set mouse scaling +proc GetMouseWheelMove*(): float32 {.RLAPI, importc: "GetMouseWheelMove".} # Get mouse wheel movement Y +proc SetMouseCursor*(cursor: int32) {.RLAPI, importc: "SetMouseCursor".} # Set mouse cursor +# Input-related functions: touch +proc GetTouchX*(): int32 {.RLAPI, importc: "GetTouchX".} # Get touch position X for touch point 0 (relative to screen size) +proc GetTouchY*(): int32 {.RLAPI, importc: "GetTouchY".} # Get touch position Y for touch point 0 (relative to screen size) +proc GetTouchPosition*(index: int32): Vector2 {.RLAPI, importc: "GetTouchPosition".} # Get touch position XY for a touch point index (relative to screen size) +# ------------------------------------------------------------------------------------ +# Gestures and Touch Handling Functions (Module: gestures) +# ------------------------------------------------------------------------------------ +proc SetGesturesEnabled*(flags: uint32) {.RLAPI, importc: "SetGesturesEnabled".} # Enable a set of gestures using flags +proc IsGestureDetected*(gesture: int32): bool {.RLAPI, importc: "IsGestureDetected".} # Check if a gesture have been detected +proc GetGestureDetected*(): int32 {.RLAPI, importc: "GetGestureDetected".} # Get latest detected gesture +proc GetTouchPointsCount*(): int32 {.RLAPI, importc: "GetTouchPointsCount".} # Get touch points count +proc GetGestureHoldDuration*(): float32 {.RLAPI, importc: "GetGestureHoldDuration".} # Get gesture hold time in milliseconds +proc GetGestureDragVector*(): Vector2 {.RLAPI, importc: "GetGestureDragVector".} # Get gesture drag vector +proc GetGestureDragAngle*(): float32 {.RLAPI, importc: "GetGestureDragAngle".} # Get gesture drag angle +proc GetGesturePinchVector*(): Vector2 {.RLAPI, importc: "GetGesturePinchVector".} # Get gesture pinch delta +proc GetGesturePinchAngle*(): float32 {.RLAPI, importc: "GetGesturePinchAngle".} # Get gesture pinch angle +# ------------------------------------------------------------------------------------ +# Camera System Functions (Module: camera) +# ------------------------------------------------------------------------------------ +proc SetCameraMode*(camera: Camera; mode: int32) {.RLAPI, importc: "SetCameraMode".} # Set camera mode (multiple camera modes available) +proc UpdateCamera*(camera: ptr Camera) {.RLAPI, importc: "UpdateCamera".} # Update camera position for selected mode +proc SetCameraPanControl*(keyPan: int32) {.RLAPI, importc: "SetCameraPanControl".} # Set camera pan key to combine with mouse movement (free camera) +proc SetCameraAltControl*(keyAlt: int32) {.RLAPI, importc: "SetCameraAltControl".} # Set camera alt key to combine with mouse movement (free camera) +proc SetCameraSmoothZoomControl*(keySmoothZoom: int32) {.RLAPI, importc: "SetCameraSmoothZoomControl".} # Set camera smooth zoom key to combine with mouse (free camera) +proc SetCameraMoveControls*(keyFront: int32; keyBack: int32; keyRight: int32; keyLeft: int32; keyUp: int32; keyDown: int32) {.RLAPI, importc: "SetCameraMoveControls".} # Set camera move controls (1st person and 3rd person cameras) +# ------------------------------------------------------------------------------------ +# 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 +proc SetShapesTexture*(texture: Texture2D; source: Rectangle) {.RLAPI, importc: "SetShapesTexture".} # Set texture and rectangle to be used on shapes drawing +# Basic shapes drawing functions +proc DrawPixel*(posX: int32; posY: int32; color: Color) {.RLAPI, importc: "DrawPixel".} # Draw a pixel +proc DrawPixelV*(position: Vector2; color: Color) {.RLAPI, importc: "DrawPixelV".} # Draw a pixel (Vector version) +proc DrawLine*(startPosX: int32; startPosY: int32; endPosX: int32; endPosY: int32; color: Color) {.RLAPI, importc: "DrawLine".} # Draw a line +proc DrawLineV*(startPos: Vector2; endPos: Vector2; color: Color) {.RLAPI, importc: "DrawLineV".} # Draw a line (Vector version) +proc DrawLineEx*(startPos: Vector2; endPos: Vector2; thick: float32; color: Color) {.RLAPI, importc: "DrawLineEx".} # Draw a line defining thickness +proc DrawLineBezier*(startPos: Vector2; endPos: Vector2; thick: float32; color: Color) {.RLAPI, importc: "DrawLineBezier".} # Draw a line using cubic-bezier curves in-out +proc DrawLineBezierQuad*(startPos: Vector2; endPos: Vector2; controlPos: Vector2; thick: float32; color: Color) {.RLAPI, importc: "DrawLineBezierQuad".} # Draw line using quadratic bezier curves with a control point +proc DrawLineStrip*(points: ptr Vector2; pointsCount: int32; color: Color) {.RLAPI, importc: "DrawLineStrip".} # Draw lines sequence +proc DrawCircle*(centerX: int32; centerY: int32; radius: float32; color: Color) {.RLAPI, importc: "DrawCircle".} # Draw a color-filled circle +proc DrawCircleSector*(center: Vector2; radius: float32; startAngle: float32; endAngle: float32; segments: int32; color: Color) {.RLAPI, importc: "DrawCircleSector".} # Draw a piece of a circle +proc DrawCircleSectorLines*(center: Vector2; radius: float32; startAngle: float32; endAngle: float32; segments: int32; color: Color) {.RLAPI, importc: "DrawCircleSectorLines".} # Draw circle sector outline +proc DrawCircleGradient*(centerX: int32; centerY: int32; radius: float32; color1: Color; color2: Color) {.RLAPI, importc: "DrawCircleGradient".} # Draw a gradient-filled circle +proc DrawCircleV*(center: Vector2; radius: float32; color: Color) {.RLAPI, importc: "DrawCircleV".} # Draw a color-filled circle (Vector version) +proc DrawCircleLines*(centerX: int32; centerY: int32; radius: float32; color: Color) {.RLAPI, importc: "DrawCircleLines".} # Draw circle outline +proc DrawEllipse*(centerX: int32; centerY: int32; radiusH: float32; radiusV: float32; color: Color) {.RLAPI, importc: "DrawEllipse".} # Draw ellipse +proc DrawEllipseLines*(centerX: int32; centerY: int32; radiusH: float32; radiusV: float32; color: Color) {.RLAPI, importc: "DrawEllipseLines".} # Draw ellipse outline +proc DrawRing*(center: Vector2; innerRadius: float32; outerRadius: float32; startAngle: float32; endAngle: float32; segments: int32; color: Color) {.RLAPI, importc: "DrawRing".} # Draw ring +proc DrawRingLines*(center: Vector2; innerRadius: float32; outerRadius: float32; startAngle: float32; endAngle: float32; segments: int32; color: Color) {.RLAPI, importc: "DrawRingLines".} # Draw ring outline +proc DrawRectangle*(posX: int32; posY: int32; width: int32; height: int32; color: Color) {.RLAPI, importc: "DrawRectangle".} # Draw a color-filled rectangle +proc DrawRectangleV*(position: Vector2; size: Vector2; color: Color) {.RLAPI, importc: "DrawRectangleV".} # Draw a color-filled rectangle (Vector version) +proc DrawRectangleRec*(rec: Rectangle; color: Color) {.RLAPI, importc: "DrawRectangleRec".} # Draw a color-filled rectangle +proc DrawRectanglePro*(rec: Rectangle; origin: Vector2; rotation: float32; color: Color) {.RLAPI, importc: "DrawRectanglePro".} # Draw a color-filled rectangle with pro parameters +proc DrawRectangleGradientV*(posX: int32; posY: int32; width: int32; height: int32; color1: Color; color2: Color) {.RLAPI, importc: "DrawRectangleGradientV".} # Draw a vertical-gradient-filled rectangle +proc DrawRectangleGradientH*(posX: int32; posY: int32; width: int32; height: int32; color1: Color; color2: Color) {.RLAPI, importc: "DrawRectangleGradientH".} # Draw a horizontal-gradient-filled rectangle +proc DrawRectangleGradientEx*(rec: Rectangle; col1: Color; col2: Color; col3: Color; col4: Color) {.RLAPI, importc: "DrawRectangleGradientEx".} # Draw a gradient-filled rectangle with custom vertex colors +proc DrawRectangleLines*(posX: int32; posY: int32; width: int32; height: int32; color: Color) {.RLAPI, importc: "DrawRectangleLines".} # Draw rectangle outline +proc DrawRectangleLinesEx*(rec: Rectangle; lineThick: float32; color: Color) {.RLAPI, importc: "DrawRectangleLinesEx".} # Draw rectangle outline with extended parameters +proc DrawRectangleRounded*(rec: Rectangle; roundness: float32; segments: int32; color: Color) {.RLAPI, importc: "DrawRectangleRounded".} # Draw rectangle with rounded edges +proc DrawRectangleRoundedLines*(rec: Rectangle; roundness: float32; segments: int32; lineThick: float32; color: Color) {.RLAPI, importc: "DrawRectangleRoundedLines".} # Draw rectangle with rounded edges outline +proc DrawTriangle*(v1: Vector2; v2: Vector2; v3: Vector2; color: Color) {.RLAPI, importc: "DrawTriangle".} # Draw a color-filled triangle (vertex in counter-clockwise order!) +proc DrawTriangleLines*(v1: Vector2; v2: Vector2; v3: Vector2; color: Color) {.RLAPI, importc: "DrawTriangleLines".} # Draw triangle outline (vertex in counter-clockwise order!) +proc DrawTriangleFan*(points: ptr Vector2; pointsCount: int32; color: Color) {.RLAPI, importc: "DrawTriangleFan".} # Draw a triangle fan defined by points (first vertex is the center) +proc DrawTriangleStrip*(points: ptr Vector2; pointsCount: int32; color: Color) {.RLAPI, importc: "DrawTriangleStrip".} # Draw a triangle strip defined by points +proc DrawPoly*(center: Vector2; sides: int32; radius: float32; rotation: float32; color: Color) {.RLAPI, importc: "DrawPoly".} # Draw a regular polygon (Vector version) +proc DrawPolyLines*(center: Vector2; sides: int32; radius: float32; rotation: float32; color: Color) {.RLAPI, importc: "DrawPolyLines".} # Draw a polygon outline of n sides +proc DrawPolyLinesEx*(center: Vector2; sides: int32; radius: float32; rotation: float32; lineThick: float32; color: Color) {.RLAPI, importc: "DrawPolyLinesEx".} # Draw a polygon outline of n sides with extended parameters +# Basic shapes collision detection functions +proc CheckCollisionRecs*(rec1: Rectangle; rec2: Rectangle): bool {.RLAPI, importc: "CheckCollisionRecs".} # Check collision between two rectangles +proc CheckCollisionCircles*(center1: Vector2; radius1: float32; center2: Vector2; radius2: float32): bool {.RLAPI, importc: "CheckCollisionCircles".} # Check collision between two circles +proc CheckCollisionCircleRec*(center: Vector2; radius: float32; rec: Rectangle): bool {.RLAPI, importc: "CheckCollisionCircleRec".} # Check collision between circle and rectangle +proc CheckCollisionPointRec*(point: Vector2; rec: Rectangle): bool {.RLAPI, importc: "CheckCollisionPointRec".} # Check if point is inside rectangle +proc CheckCollisionPointCircle*(point: Vector2; center: Vector2; radius: float32): bool {.RLAPI, importc: "CheckCollisionPointCircle".} # Check if point is inside circle +proc CheckCollisionPointTriangle*(point: Vector2; p1: Vector2; p2: Vector2; p3: Vector2): bool {.RLAPI, importc: "CheckCollisionPointTriangle".} # Check if point is inside a triangle +proc CheckCollisionLines*(startPos1: Vector2; endPos1: Vector2; startPos2: Vector2; endPos2: Vector2; collisionPoint: ptr Vector2): bool {.RLAPI, importc: "CheckCollisionLines".} # Check the collision between two lines defined by two points each, returns collision point by reference +proc GetCollisionRec*(rec1: Rectangle; rec2: Rectangle): Rectangle {.RLAPI, importc: "GetCollisionRec".} # Get collision rectangle for two rectangles collision +# ------------------------------------------------------------------------------------ +# Texture Loading and Drawing Functions (Module: textures) +# ------------------------------------------------------------------------------------ +# Image loading functions +# NOTE: This functions do not require GPU access +proc LoadImage*(fileName: cstring): Image {.RLAPI, importc: "LoadImage".} # Load image from file into CPU memory (RAM) +proc LoadImageRaw*(fileName: cstring; width: int32; height: int32; format: int32; headerSize: int32): Image {.RLAPI, importc: "LoadImageRaw".} # Load image from RAW file data +proc LoadImageAnim*(fileName: cstring; frames: pointer): Image {.RLAPI, importc: "LoadImageAnim".} # Load image sequence from file (frames appended to image.data) +proc LoadImageFromMemory*(fileType: cstring; fileData: UncheckedArray[byte]; dataSize: int32): Image {.RLAPI, importc: "LoadImageFromMemory".} # Load image from memory buffer, fileType refers to extension: i.e. '.png' +proc LoadImageFromTexture*(texture: Texture2D): Image {.RLAPI, importc: "LoadImageFromTexture".} # Load image from GPU texture data +proc LoadImageFromScreen*(): Image {.RLAPI, importc: "LoadImageFromScreen".} # Load image from screen buffer and (screenshot) +proc UnloadImage*(image: Image) {.RLAPI, importc: "UnloadImage".} # Unload image from CPU memory (RAM) +proc ExportImage*(image: Image; fileName: cstring): bool {.RLAPI, importc: "ExportImage".} # Export image data to file, returns true on success +proc ExportImageAsCode*(image: Image; fileName: cstring): bool {.RLAPI, importc: "ExportImageAsCode".} # Export image as code file defining an array of bytes, returns true on success +# Image generation functions +proc GenImageColor*(width: int32; height: int32; color: Color): Image {.RLAPI, importc: "GenImageColor".} # Generate image: plain color +proc GenImageGradientV*(width: int32; height: int32; top: Color; bottom: Color): Image {.RLAPI, importc: "GenImageGradientV".} # Generate image: vertical gradient +proc GenImageGradientH*(width: int32; height: int32; left: Color; right: Color): Image {.RLAPI, importc: "GenImageGradientH".} # Generate image: horizontal gradient +proc GenImageGradientRadial*(width: int32; height: int32; density: float32; inner: Color; outer: Color): Image {.RLAPI, importc: "GenImageGradientRadial".} # Generate image: radial gradient +proc GenImageChecked*(width: int32; height: int32; checksX: int32; checksY: int32; col1: Color; col2: Color): Image {.RLAPI, importc: "GenImageChecked".} # Generate image: checked +proc GenImageWhiteNoise*(width: int32; height: int32; factor: float32): Image {.RLAPI, importc: "GenImageWhiteNoise".} # Generate image: white noise +proc GenImagePerlinNoise*(width: int32; height: int32; offsetX: int32; offsetY: int32; scale: float32): Image {.RLAPI, importc: "GenImagePerlinNoise".} # Generate image: perlin noise +proc GenImageCellular*(width: int32; height: int32; tileSize: int32): Image {.RLAPI, importc: "GenImageCellular".} # Generate image: cellular algorithm. Bigger tileSize means bigger cells +# Image manipulation functions +proc ImageCopy*(image: Image): Image {.RLAPI, importc: "ImageCopy".} # Create an image duplicate (useful for transformations) +proc ImageFromImage*(image: Image; rec: Rectangle): Image {.RLAPI, importc: "ImageFromImage".} # Create an image from another image piece +proc ImageText*(text: cstring; fontSize: int32; color: Color): Image {.RLAPI, importc: "ImageText".} # Create an image from text (default font) +proc ImageTextEx*(font: Font; text: cstring; fontSize: float32; spacing: float32; tint: Color): Image {.RLAPI, importc: "ImageTextEx".} # Create an image from text (custom sprite font) +proc ImageFormat*(image: ptr Image; newFormat: int32) {.RLAPI, importc: "ImageFormat".} # Convert image data to desired format +proc ImageToPOT*(image: ptr Image; fill: Color) {.RLAPI, importc: "ImageToPOT".} # Convert image to POT (power-of-two) +proc ImageCrop*(image: ptr Image; crop: Rectangle) {.RLAPI, importc: "ImageCrop".} # Crop an image to a defined rectangle +proc ImageAlphaCrop*(image: ptr Image; threshold: float32) {.RLAPI, importc: "ImageAlphaCrop".} # Crop image depending on alpha value +proc ImageAlphaClear*(image: ptr Image; color: Color; threshold: float32) {.RLAPI, importc: "ImageAlphaClear".} # Clear alpha channel to desired color +proc ImageAlphaMask*(image: ptr Image; alphaMask: Image) {.RLAPI, importc: "ImageAlphaMask".} # Apply alpha mask to image +proc ImageAlphaPremultiply*(image: ptr Image) {.RLAPI, importc: "ImageAlphaPremultiply".} # Premultiply alpha channel +proc ImageResize*(image: ptr Image; newWidth: int32; newHeight: int32) {.RLAPI, importc: "ImageResize".} # Resize image (Bicubic scaling algorithm) +proc ImageResizeNN*(image: ptr Image; newWidth: int32; newHeight: int32) {.RLAPI, importc: "ImageResizeNN".} # Resize image (Nearest-Neighbor scaling algorithm) +proc ImageResizeCanvas*(image: ptr Image; newWidth: int32; newHeight: int32; offsetX: int32; offsetY: int32; fill: Color) {.RLAPI, importc: "ImageResizeCanvas".} # Resize canvas and fill with color +proc ImageMipmaps*(image: ptr Image) {.RLAPI, importc: "ImageMipmaps".} # Compute all mipmap levels for a provided image +proc ImageDither*(image: ptr Image; rBpp: int32; gBpp: int32; bBpp: int32; aBpp: int32) {.RLAPI, importc: "ImageDither".} # Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +proc ImageFlipVertical*(image: ptr Image) {.RLAPI, importc: "ImageFlipVertical".} # Flip image vertically +proc ImageFlipHorizontal*(image: ptr Image) {.RLAPI, importc: "ImageFlipHorizontal".} # Flip image horizontally +proc ImageRotateCW*(image: ptr Image) {.RLAPI, importc: "ImageRotateCW".} # Rotate image clockwise 90deg +proc ImageRotateCCW*(image: ptr Image) {.RLAPI, importc: "ImageRotateCCW".} # Rotate image counter-clockwise 90deg +proc ImageColorTint*(image: ptr Image; color: Color) {.RLAPI, importc: "ImageColorTint".} # Modify image color: tint +proc ImageColorInvert*(image: ptr Image) {.RLAPI, importc: "ImageColorInvert".} # Modify image color: invert +proc ImageColorGrayscale*(image: ptr Image) {.RLAPI, importc: "ImageColorGrayscale".} # Modify image color: grayscale +proc ImageColorContrast*(image: ptr Image; contrast: float32) {.RLAPI, importc: "ImageColorContrast".} # Modify image color: contrast (-100 to 100) +proc ImageColorBrightness*(image: ptr Image; brightness: int32) {.RLAPI, importc: "ImageColorBrightness".} # Modify image color: brightness (-255 to 255) +proc ImageColorReplace*(image: ptr Image; color: Color; replace: Color) {.RLAPI, importc: "ImageColorReplace".} # Modify image color: replace color +proc LoadImageColors*(image: Image): ptr Color {.RLAPI, importc: "LoadImageColors".} # Load color data from image as a Color array (RGBA - 32bit) +proc LoadImagePalette*(image: Image; maxPaletteSize: int32; colorsCount: pointer): ptr Color {.RLAPI, importc: "LoadImagePalette".} # Load colors palette from image as a Color array (RGBA - 32bit) +proc UnloadImageColors*(colors: ptr Color) {.RLAPI, importc: "UnloadImageColors".} # Unload color data loaded with LoadImageColors() +proc UnloadImagePalette*(colors: ptr Color) {.RLAPI, importc: "UnloadImagePalette".} # Unload colors palette loaded with LoadImagePalette() +proc GetImageAlphaBorder*(image: Image; threshold: float32): Rectangle {.RLAPI, importc: "GetImageAlphaBorder".} # Get image alpha border rectangle +# Image drawing functions +# NOTE: Image software-rendering functions (CPU) +proc ImageClearBackground*(dst: ptr Image; color: Color) {.RLAPI, importc: "ImageClearBackground".} # Clear image background with given color +proc ImageDrawPixel*(dst: ptr Image; posX: int32; posY: int32; color: Color) {.RLAPI, importc: "ImageDrawPixel".} # Draw pixel within an image +proc ImageDrawPixelV*(dst: ptr Image; position: Vector2; color: Color) {.RLAPI, importc: "ImageDrawPixelV".} # Draw pixel within an image (Vector version) +proc ImageDrawLine*(dst: ptr Image; startPosX: int32; startPosY: int32; endPosX: int32; endPosY: int32; color: Color) {.RLAPI, importc: "ImageDrawLine".} # Draw line within an image +proc ImageDrawLineV*(dst: ptr Image; start: Vector2; endx: Vector2; color: Color) {.RLAPI, importc: "ImageDrawLineV".} # Draw line within an image (Vector version) +proc ImageDrawCircle*(dst: ptr Image; centerX: int32; centerY: int32; radius: int32; color: Color) {.RLAPI, importc: "ImageDrawCircle".} # Draw circle within an image +proc ImageDrawCircleV*(dst: ptr Image; center: Vector2; radius: int32; color: Color) {.RLAPI, importc: "ImageDrawCircleV".} # Draw circle within an image (Vector version) +proc ImageDrawRectangle*(dst: ptr Image; posX: int32; posY: int32; width: int32; height: int32; color: Color) {.RLAPI, importc: "ImageDrawRectangle".} # Draw rectangle within an image +proc ImageDrawRectangleV*(dst: ptr Image; position: Vector2; size: Vector2; color: Color) {.RLAPI, importc: "ImageDrawRectangleV".} # Draw rectangle within an image (Vector version) +proc ImageDrawRectangleRec*(dst: ptr Image; rec: Rectangle; color: Color) {.RLAPI, importc: "ImageDrawRectangleRec".} # Draw rectangle within an image +proc ImageDrawRectangleLines*(dst: ptr Image; rec: Rectangle; thick: int32; color: Color) {.RLAPI, importc: "ImageDrawRectangleLines".} # Draw rectangle lines within an image +proc ImageDraw*(dst: ptr Image; src: Image; srcRec: Rectangle; dstRec: Rectangle; tint: Color) {.RLAPI, importc: "ImageDraw".} # Draw a source image within a destination image (tint applied to source) +proc ImageDrawText*(dst: ptr Image; text: cstring; posX: int32; posY: int32; fontSize: int32; color: Color) {.RLAPI, importc: "ImageDrawText".} # Draw text (using default font) within an image (destination) +proc ImageDrawTextEx*(dst: ptr Image; font: Font; text: cstring; position: Vector2; fontSize: float32; spacing: float32; tint: Color) {.RLAPI, importc: "ImageDrawTextEx".} # Draw text (custom sprite font) within an image (destination) +# Texture loading functions +# NOTE: These functions require GPU access +proc LoadTexture*(fileName: cstring): Texture2D {.RLAPI, importc: "LoadTexture".} # Load texture from file into GPU memory (VRAM) +proc LoadTextureFromImage*(image: Image): Texture2D {.RLAPI, importc: "LoadTextureFromImage".} # Load texture from image data +proc LoadTextureCubemap*(image: Image; layout: int32): TextureCubemap {.RLAPI, importc: "LoadTextureCubemap".} # Load cubemap from image, multiple image cubemap layouts supported +proc LoadRenderTexture*(width: int32; height: int32): RenderTexture2D {.RLAPI, importc: "LoadRenderTexture".} # Load texture for rendering (framebuffer) +proc UnloadTexture*(texture: Texture2D) {.RLAPI, importc: "UnloadTexture".} # Unload texture from GPU memory (VRAM) +proc UnloadRenderTexture*(target: RenderTexture2D) {.RLAPI, importc: "UnloadRenderTexture".} # Unload render texture from GPU memory (VRAM) +proc UpdateTexture*(texture: Texture2D; pixels: pointer) {.RLAPI, importc: "UpdateTexture".} # Update GPU texture with new data +proc UpdateTextureRec*(texture: Texture2D; rec: Rectangle; pixels: pointer) {.RLAPI, importc: "UpdateTextureRec".} # Update GPU texture rectangle with new data +# Texture configuration functions +proc GenTextureMipmaps*(texture: ptr Texture2D) {.RLAPI, importc: "GenTextureMipmaps".} # Generate GPU mipmaps for a texture +proc SetTextureFilter*(texture: Texture2D; filter: int32) {.RLAPI, importc: "SetTextureFilter".} # Set texture scaling filter mode +proc SetTextureWrap*(texture: Texture2D; wrap: int32) {.RLAPI, importc: "SetTextureWrap".} # Set texture wrapping mode +# Texture drawing functions +proc DrawTexture*(texture: Texture2D; posX: int32; posY: int32; tint: Color) {.RLAPI, importc: "DrawTexture".} # Draw a Texture2D +proc DrawTextureV*(texture: Texture2D; position: Vector2; tint: Color) {.RLAPI, importc: "DrawTextureV".} # Draw a Texture2D with position defined as Vector2 +proc DrawTextureEx*(texture: Texture2D; position: Vector2; rotation: float32; scale: float32; tint: Color) {.RLAPI, importc: "DrawTextureEx".} # Draw a Texture2D with extended parameters +proc DrawTextureRec*(texture: Texture2D; source: Rectangle; position: Vector2; tint: Color) {.RLAPI, importc: "DrawTextureRec".} # Draw a part of a texture defined by a rectangle +proc DrawTextureQuad*(texture: Texture2D; tiling: Vector2; offset: Vector2; quad: Rectangle; tint: Color) {.RLAPI, importc: "DrawTextureQuad".} # Draw texture quad with tiling and offset parameters +proc DrawTextureTiled*(texture: Texture2D; source: Rectangle; dest: Rectangle; origin: Vector2; rotation: float32; scale: float32; tint: Color) {.RLAPI, importc: "DrawTextureTiled".} # Draw part of a texture (defined by a rectangle) with rotation and scale tiled into dest. +proc DrawTexturePro*(texture: Texture2D; source: Rectangle; dest: Rectangle; origin: Vector2; rotation: float32; tint: Color) {.RLAPI, importc: "DrawTexturePro".} # Draw a part of a texture defined by a rectangle with 'pro' parameters +proc DrawTextureNPatch*(texture: Texture2D; nPatchInfo: NPatchInfo; dest: Rectangle; origin: Vector2; rotation: float32; tint: Color) {.RLAPI, importc: "DrawTextureNPatch".} # Draws a texture (or part of it) that stretches or shrinks nicely +proc DrawTexturePoly*(texture: Texture2D; center: Vector2; points: ptr Vector2; texcoords: ptr Vector2; pointsCount: int32; tint: Color) {.RLAPI, importc: "DrawTexturePoly".} # Draw a textured polygon +# Color/pixel related functions +proc Fade*(color: Color; alpha: float32): Color {.RLAPI, importc: "Fade".} # Get color with alpha applied, alpha goes from 0.0f to 1.0f +proc ColorToInt*(color: Color): int32 {.RLAPI, importc: "ColorToInt".} # Get hexadecimal value for a Color +proc ColorNormalize*(color: Color): Vector4 {.RLAPI, importc: "ColorNormalize".} # Get Color normalized as float [0..1] +proc ColorFromNormalized*(normalized: Vector4): Color {.RLAPI, importc: "ColorFromNormalized".} # Get Color from normalized values [0..1] +proc ColorToHSV*(color: Color): Vector3 {.RLAPI, importc: "ColorToHSV".} # Get HSV values for a Color, hue [0..360], saturation/value [0..1] +proc ColorFromHSV*(hue: float32; saturation: float32; value: float32): Color {.RLAPI, importc: "ColorFromHSV".} # Get a Color from HSV values, hue [0..360], saturation/value [0..1] +proc ColorAlpha*(color: Color; alpha: float32): Color {.RLAPI, importc: "ColorAlpha".} # Get color with alpha applied, alpha goes from 0.0f to 1.0f +proc ColorAlphaBlend*(dst: Color; src: Color; tint: Color): Color {.RLAPI, importc: "ColorAlphaBlend".} # Get src alpha-blended into dst color with tint +proc GetColor*(hexValue: int32): Color {.RLAPI, importc: "GetColor".} # Get Color structure from hexadecimal value +proc GetPixelColor*(srcPtr: pointer; format: int32): Color {.RLAPI, importc: "GetPixelColor".} # Get Color from a source pixel pointer of certain format +proc SetPixelColor*(dstPtr: pointer; color: Color; format: int32) {.RLAPI, importc: "SetPixelColor".} # Set color formatted into destination pixel pointer +proc GetPixelDataSize*(width: int32; height: int32; format: int32): int32 {.RLAPI, importc: "GetPixelDataSize".} # Get pixel data size in bytes for certain format +# ------------------------------------------------------------------------------------ +# Font Loading and Text Drawing Functions (Module: text) +# ------------------------------------------------------------------------------------ +# Font loading/unloading functions +proc GetFontDefault*(): Font {.RLAPI, importc: "GetFontDefault".} # Get the default Font +proc LoadFont*(fileName: cstring): Font {.RLAPI, importc: "LoadFont".} # Load font from file into GPU memory (VRAM) +proc LoadFontEx*(fileName: cstring; fontSize: int32; fontChars: pointer; charsCount: int32): Font {.RLAPI, importc: "LoadFontEx".} # Load font from file with extended parameters +proc LoadFontFromImage*(image: Image; key: Color; firstChar: int32): Font {.RLAPI, importc: "LoadFontFromImage".} # Load font from Image (XNA style) +proc LoadFontFromMemory*(fileType: cstring; fileData: UncheckedArray[byte]; dataSize: int32; fontSize: int32; fontChars: pointer; charsCount: int32): Font {.RLAPI, importc: "LoadFontFromMemory".} # Load font from memory buffer, fileType refers to extension: i.e. '.ttf' +proc LoadFontData*(fileData: UncheckedArray[byte]; dataSize: int32; fontSize: int32; fontChars: pointer; charsCount: int32; typex: int32): ptr CharInfo {.RLAPI, importc: "LoadFontData".} # Load font data for further use +proc GenImageFontAtlas*(chars: ptr ptr CharInfo; recs: ptr Rectangle; charsCount: int32; fontSize: int32; padding: int32; packMethod: int32): Image {.RLAPI, importc: "GenImageFontAtlas".} # Generate image font atlas using chars info +proc UnloadFontData*(chars: ptr CharInfo; charsCount: int32) {.RLAPI, importc: "UnloadFontData".} # Unload font chars info data (RAM) +proc UnloadFont*(font: Font) {.RLAPI, importc: "UnloadFont".} # Unload Font from GPU memory (VRAM) +# Text drawing functions +proc DrawFPS*(posX: int32; posY: int32) {.RLAPI, importc: "DrawFPS".} # Draw current FPS +proc DrawText*(text: cstring; posX: int32; posY: int32; fontSize: int32; color: Color) {.RLAPI, importc: "DrawText".} # Draw text (using default font) +proc DrawTextEx*(font: Font; text: cstring; position: Vector2; fontSize: float32; spacing: float32; tint: Color) {.RLAPI, importc: "DrawTextEx".} # Draw text using font and additional parameters +proc DrawTextRec*(font: Font; text: cstring; rec: Rectangle; fontSize: float32; spacing: float32; wordWrap: bool; tint: Color) {.RLAPI, importc: "DrawTextRec".} # Draw text using font inside rectangle limits +proc DrawTextRecEx*(font: Font; text: cstring; rec: Rectangle; fontSize: float32; spacing: float32; wordWrap: bool; tint: Color; selectStart: int32; selectLength: int32; selectTint: Color; selectBackTint: Color) {.RLAPI, importc: "DrawTextRecEx".} # Draw text using font inside rectangle limits with support for text selection +proc DrawTextCodepoint*(font: Font; codepoint: int32; position: Vector2; fontSize: float32; tint: Color) {.RLAPI, importc: "DrawTextCodepoint".} # Draw one character (codepoint) +# Text misc. functions +proc MeasureText*(text: cstring; fontSize: int32): int32 {.RLAPI, importc: "MeasureText".} # Measure string width for default font +proc MeasureTextEx*(font: Font; text: cstring; fontSize: float32; spacing: float32): Vector2 {.RLAPI, importc: "MeasureTextEx".} # Measure string size for Font +proc GetGlyphIndex*(font: Font; codepoint: int32): int32 {.RLAPI, importc: "GetGlyphIndex".} # Get index position for a unicode character on font +# Text strings management functions (no utf8 strings, only byte chars) +# NOTE: Some strings allocate memory internally for returned strings, just be careful! +proc TextCopy*(dst: ptr char; src: cstring): int32 {.RLAPI, importc: "TextCopy".} # Copy one string to another, returns bytes copied +proc TextIsEqual*(text1: cstring; text2: cstring): bool {.RLAPI, importc: "TextIsEqual".} # Check if two text string are equal +proc TextLength*(text: cstring): uint32 {.RLAPI, importc: "TextLength".} # Get text length, checks for '\0' ending +proc TextFormat*(text: cstring): cstring {.RLAPI, varargs, importc: "TextFormat".} # Text formatting with variables (sprintf style) +proc TextSubtext*(text: cstring; position: int32; length: int32): cstring {.RLAPI, importc: "TextSubtext".} # Get a piece of a text string +proc TextReplace*(text: ptr char; replace: cstring; by: cstring): ptr char {.RLAPI, importc: "TextReplace".} # Replace text string (memory must be freed!) +proc TextInsert*(text: cstring; insert: cstring; position: int32): ptr char {.RLAPI, importc: "TextInsert".} # Insert text in a position (memory must be freed!) +proc TextJoin*(textList: cstring; count: int32; delimiter: cstring): cstring {.RLAPI, importc: "TextJoin".} # Join text strings with delimiter +proc TextSplit*(text: cstring; delimiter: char; count: pointer): cstring {.RLAPI, importc: "TextSplit".} # Split text into multiple strings +proc TextAppend*(text: ptr char; append: cstring; position: pointer) {.RLAPI, importc: "TextAppend".} # Append text at specific position and move cursor! +proc TextFindIndex*(text: cstring; find: cstring): int32 {.RLAPI, importc: "TextFindIndex".} # Find first text occurrence within a string +proc TextToUpper*(text: cstring): cstring {.RLAPI, importc: "TextToUpper".} # Get upper case version of provided string +proc TextToLower*(text: cstring): cstring {.RLAPI, importc: "TextToLower".} # Get lower case version of provided string +proc TextToPascal*(text: cstring): cstring {.RLAPI, importc: "TextToPascal".} # Get Pascal case notation version of provided string +proc TextToInteger*(text: cstring): int32 {.RLAPI, importc: "TextToInteger".} # Get integer value from text (negative values not supported) +proc TextToUtf8*(codepoints: pointer; length: int32): ptr char {.RLAPI, importc: "TextToUtf8".} # Encode text codepoint into utf8 text (memory must be freed!) +# UTF8 text strings management functions +proc LoadCodepoints*(text: cstring; count: pointer): pointer {.RLAPI, importc: "LoadCodepoints".} # Load all codepoints from a UTF8 text string, codepoints count returned by parameter +proc UnloadCodepoints*(codepoints: pointer) {.RLAPI, importc: "UnloadCodepoints".} # Unload codepoints data from memory +proc GetCodepointsCount*(text: cstring): int32 {.RLAPI, importc: "GetCodepointsCount".} # Get total number of characters (codepoints) in a UTF8 encoded string +proc GetCodepoint*(text: cstring; bytesProcessed: pointer): int32 {.RLAPI, importc: "GetCodepoint".} # Get next codepoint in a UTF8 encoded string, 0x3f('?') is returned on failure +proc CodepointToUtf8*(codepoint: int32; byteLength: pointer): cstring {.RLAPI, importc: "CodepointToUtf8".} # Encode codepoint into utf8 text (char array length returned as parameter) +# ------------------------------------------------------------------------------------ +# Basic 3d Shapes Drawing Functions (Module: models) +# ------------------------------------------------------------------------------------ +# Basic geometric 3D shapes drawing functions +proc DrawLine3D*(startPos: Vector3; endPos: Vector3; color: Color) {.RLAPI, importc: "DrawLine3D".} # Draw a line in 3D world space +proc DrawPoint3D*(position: Vector3; color: Color) {.RLAPI, importc: "DrawPoint3D".} # Draw a point in 3D space, actually a small line +proc DrawCircle3D*(center: Vector3; radius: float32; rotationAxis: Vector3; rotationAngle: float32; color: Color) {.RLAPI, importc: "DrawCircle3D".} # Draw a circle in 3D world space +proc DrawTriangle3D*(v1: Vector3; v2: Vector3; v3: Vector3; color: Color) {.RLAPI, importc: "DrawTriangle3D".} # Draw a color-filled triangle (vertex in counter-clockwise order!) +proc DrawTriangleStrip3D*(points: ptr Vector3; pointsCount: int32; color: Color) {.RLAPI, importc: "DrawTriangleStrip3D".} # Draw a triangle strip defined by points +proc DrawCube*(position: Vector3; width: float32; height: float32; length: float32; color: Color) {.RLAPI, importc: "DrawCube".} # Draw cube +proc DrawCubeV*(position: Vector3; size: Vector3; color: Color) {.RLAPI, importc: "DrawCubeV".} # Draw cube (Vector version) +proc DrawCubeWires*(position: Vector3; width: float32; height: float32; length: float32; color: Color) {.RLAPI, importc: "DrawCubeWires".} # Draw cube wires +proc DrawCubeWiresV*(position: Vector3; size: Vector3; color: Color) {.RLAPI, importc: "DrawCubeWiresV".} # Draw cube wires (Vector version) +proc DrawCubeTexture*(texture: Texture2D; position: Vector3; width: float32; height: float32; length: float32; color: Color) {.RLAPI, importc: "DrawCubeTexture".} # Draw cube textured +proc DrawSphere*(centerPos: Vector3; radius: float32; color: Color) {.RLAPI, importc: "DrawSphere".} # Draw sphere +proc DrawSphereEx*(centerPos: Vector3; radius: float32; rings: int32; slices: int32; color: Color) {.RLAPI, importc: "DrawSphereEx".} # Draw sphere with extended parameters +proc DrawSphereWires*(centerPos: Vector3; radius: float32; rings: int32; slices: int32; color: Color) {.RLAPI, importc: "DrawSphereWires".} # Draw sphere wires +proc DrawCylinder*(position: Vector3; radiusTop: float32; radiusBottom: float32; height: float32; slices: int32; color: Color) {.RLAPI, importc: "DrawCylinder".} # Draw a cylinder/cone +proc DrawCylinderWires*(position: Vector3; radiusTop: float32; radiusBottom: float32; height: float32; slices: int32; color: Color) {.RLAPI, importc: "DrawCylinderWires".} # Draw a cylinder/cone wires +proc DrawPlane*(centerPos: Vector3; size: Vector2; color: Color) {.RLAPI, importc: "DrawPlane".} # Draw a plane XZ +proc DrawRay*(ray: Ray; color: Color) {.RLAPI, importc: "DrawRay".} # Draw a ray line +proc DrawGrid*(slices: int32; spacing: float32) {.RLAPI, importc: "DrawGrid".} # Draw a grid (centered at (0, 0, 0)) +# ------------------------------------------------------------------------------------ +# Model 3d Loading and Drawing Functions (Module: models) +# ------------------------------------------------------------------------------------ +# Model loading/unloading functions +proc LoadModel*(fileName: cstring): Model {.RLAPI, importc: "LoadModel".} # Load model from files (meshes and materials) +proc LoadModelFromMesh*(mesh: Mesh): Model {.RLAPI, importc: "LoadModelFromMesh".} # Load model from generated mesh (default material) +proc UnloadModel*(model: Model) {.RLAPI, importc: "UnloadModel".} # Unload model (including meshes) from memory (RAM and/or VRAM) +proc UnloadModelKeepMeshes*(model: Model) {.RLAPI, importc: "UnloadModelKeepMeshes".} # Unload model (but not meshes) from memory (RAM and/or VRAM) +# Mesh loading/unloading functions +proc UploadMesh*(mesh: ptr Mesh; dynamic: bool) {.RLAPI, importc: "UploadMesh".} # Upload mesh vertex data in GPU and provide VAO/VBO ids +proc UpdateMeshBuffer*(mesh: Mesh; index: int32; data: pointer; dataSize: int32; offset: int32) {.RLAPI, importc: "UpdateMeshBuffer".} # Update mesh vertex data in GPU for a specific buffer index +proc DrawMesh*(mesh: Mesh; material: Material; transform: Matrix) {.RLAPI, importc: "DrawMesh".} # Draw a 3d mesh with material and transform +proc DrawMeshInstanced*(mesh: Mesh; material: Material; transforms: ptr Matrix; instances: int32) {.RLAPI, importc: "DrawMeshInstanced".} # Draw multiple mesh instances with material and different transforms +proc UnloadMesh*(mesh: Mesh) {.RLAPI, importc: "UnloadMesh".} # Unload mesh data from CPU and GPU +proc ExportMesh*(mesh: Mesh; fileName: cstring): bool {.RLAPI, importc: "ExportMesh".} # Export mesh data to file, returns true on success +# Material loading/unloading functions +proc LoadMaterials*(fileName: cstring; materialCount: pointer): ptr Material {.RLAPI, importc: "LoadMaterials".} # Load materials from model file +proc LoadMaterialDefault*(): Material {.RLAPI, importc: "LoadMaterialDefault".} # Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps) +proc UnloadMaterial*(material: Material) {.RLAPI, importc: "UnloadMaterial".} # Unload material from GPU memory (VRAM) +proc SetMaterialTexture*(material: ptr Material; mapType: int32; texture: Texture2D) {.RLAPI, importc: "SetMaterialTexture".} # Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...) +proc SetModelMeshMaterial*(model: ptr Model; meshId: int32; materialId: int32) {.RLAPI, importc: "SetModelMeshMaterial".} # Set material for a mesh +# Model animations loading/unloading functions +proc LoadModelAnimations*(fileName: cstring; animsCount: pointer): ptr ModelAnimation {.RLAPI, importc: "LoadModelAnimations".} # Load model animations from file +proc UpdateModelAnimation*(model: Model; anim: ModelAnimation; frame: int32) {.RLAPI, importc: "UpdateModelAnimation".} # Update model animation pose +proc UnloadModelAnimation*(anim: ModelAnimation) {.RLAPI, importc: "UnloadModelAnimation".} # Unload animation data +proc UnloadModelAnimations*(animations: proc(): ModelAnimation; count: uint32) {.RLAPI, importc: "UnloadModelAnimations".} # Unload animation array data +proc IsModelAnimationValid*(model: Model; anim: ModelAnimation): bool {.RLAPI, importc: "IsModelAnimationValid".} # Check model animation skeleton match +# Mesh generation functions +proc GenMeshPoly*(sides: int32; radius: float32): Mesh {.RLAPI, importc: "GenMeshPoly".} # Generate polygonal mesh +proc GenMeshPlane*(width: float32; length: float32; resX: int32; resZ: int32): Mesh {.RLAPI, importc: "GenMeshPlane".} # Generate plane mesh (with subdivisions) +proc GenMeshCube*(width: float32; height: float32; length: float32): Mesh {.RLAPI, importc: "GenMeshCube".} # Generate cuboid mesh +proc GenMeshSphere*(radius: float32; rings: int32; slices: int32): Mesh {.RLAPI, importc: "GenMeshSphere".} # Generate sphere mesh (standard sphere) +proc GenMeshHemiSphere*(radius: float32; rings: int32; slices: int32): Mesh {.RLAPI, importc: "GenMeshHemiSphere".} # Generate half-sphere mesh (no bottom cap) +proc GenMeshCylinder*(radius: float32; height: float32; slices: int32): Mesh {.RLAPI, importc: "GenMeshCylinder".} # Generate cylinder mesh +proc GenMeshTorus*(radius: float32; size: float32; radSeg: int32; sides: int32): Mesh {.RLAPI, importc: "GenMeshTorus".} # Generate torus mesh +proc GenMeshKnot*(radius: float32; size: float32; radSeg: int32; sides: int32): Mesh {.RLAPI, importc: "GenMeshKnot".} # Generate trefoil knot mesh +proc GenMeshHeightmap*(heightmap: Image; size: Vector3): Mesh {.RLAPI, importc: "GenMeshHeightmap".} # Generate heightmap mesh from image data +proc GenMeshCubicmap*(cubicmap: Image; cubeSize: Vector3): Mesh {.RLAPI, importc: "GenMeshCubicmap".} # Generate cubes-based map mesh from image data +# Mesh manipulation functions +proc GetMeshBoundingBox*(mesh: Mesh): BoundingBox {.RLAPI, importc: "GetMeshBoundingBox".} # Compute mesh bounding box limits +proc GenMeshTangents*(mesh: ptr Mesh) {.RLAPI, importc: "GenMeshTangents".} # Compute mesh tangents +proc GenMeshBinormals*(mesh: ptr Mesh) {.RLAPI, importc: "GenMeshBinormals".} # Compute mesh binormals +# Model drawing functions +proc DrawModel*(model: Model; position: Vector3; scale: float32; tint: Color) {.RLAPI, importc: "DrawModel".} # Draw a model (with texture if set) +proc DrawModelEx*(model: Model; position: Vector3; rotationAxis: Vector3; rotationAngle: float32; scale: Vector3; tint: Color) {.RLAPI, importc: "DrawModelEx".} # Draw a model with extended parameters +proc DrawModelWires*(model: Model; position: Vector3; scale: float32; tint: Color) {.RLAPI, importc: "DrawModelWires".} # Draw a model wires (with texture if set) +proc DrawModelWiresEx*(model: Model; position: Vector3; rotationAxis: Vector3; rotationAngle: float32; scale: Vector3; tint: Color) {.RLAPI, importc: "DrawModelWiresEx".} # Draw a model wires (with texture if set) with extended parameters +proc DrawBoundingBox*(box: BoundingBox; color: Color) {.RLAPI, importc: "DrawBoundingBox".} # Draw bounding box (wires) +proc DrawBillboard*(camera: Camera; texture: Texture2D; position: Vector3; size: float32; tint: Color) {.RLAPI, importc: "DrawBillboard".} # Draw a billboard texture +proc DrawBillboardRec*(camera: Camera; texture: Texture2D; source: Rectangle; position: Vector3; size: Vector2; tint: Color) {.RLAPI, importc: "DrawBillboardRec".} # Draw a billboard texture defined by source +proc DrawBillboardPro*(camera: Camera; texture: Texture2D; source: Rectangle; position: Vector3; size: Vector2; origin: Vector2; rotation: float32; tint: Color) {.RLAPI, importc: "DrawBillboardPro".} # Draw a billboard texture defined by source and rotation +# Collision detection functions +proc CheckCollisionSpheres*(center1: Vector3; radius1: float32; center2: Vector3; radius2: float32): bool {.RLAPI, importc: "CheckCollisionSpheres".} # Check collision between two spheres +proc CheckCollisionBoxes*(box1: BoundingBox; box2: BoundingBox): bool {.RLAPI, importc: "CheckCollisionBoxes".} # Check collision between two bounding boxes +proc CheckCollisionBoxSphere*(box: BoundingBox; center: Vector3; radius: float32): bool {.RLAPI, importc: "CheckCollisionBoxSphere".} # Check collision between box and sphere +proc GetRayCollisionSphere*(ray: Ray; center: Vector3; radius: float32): RayCollision {.RLAPI, importc: "GetRayCollisionSphere".} # Get collision info between ray and sphere +proc GetRayCollisionBox*(ray: Ray; box: BoundingBox): RayCollision {.RLAPI, importc: "GetRayCollisionBox".} # Get collision info between ray and box +proc GetRayCollisionModel*(ray: Ray; model: Model): RayCollision {.RLAPI, importc: "GetRayCollisionModel".} # Get collision info between ray and model +proc GetRayCollisionMesh*(ray: Ray; mesh: Mesh; transform: Matrix): RayCollision {.RLAPI, importc: "GetRayCollisionMesh".} # Get collision info between ray and mesh +proc GetRayCollisionTriangle*(ray: Ray; p1: Vector3; p2: Vector3; p3: Vector3): RayCollision {.RLAPI, importc: "GetRayCollisionTriangle".} # Get collision info between ray and triangle +proc GetRayCollisionQuad*(ray: Ray; p1: Vector3; p2: Vector3; p3: Vector3; p4: Vector3): RayCollision {.RLAPI, importc: "GetRayCollisionQuad".} # Get collision info between ray and quad +# ------------------------------------------------------------------------------------ +# Audio Loading and Playing Functions (Module: audio) +# ------------------------------------------------------------------------------------ +# Audio device management functions +proc InitAudioDevice*() {.RLAPI, importc: "InitAudioDevice".} # Initialize audio device and context +proc CloseAudioDevice*() {.RLAPI, importc: "CloseAudioDevice".} # Close the audio device and context +proc IsAudioDeviceReady*(): bool {.RLAPI, importc: "IsAudioDeviceReady".} # Check if audio device has been initialized successfully +proc SetMasterVolume*(volume: float32) {.RLAPI, importc: "SetMasterVolume".} # Set master volume (listener) +# Wave/Sound loading/unloading functions +proc LoadWave*(fileName: cstring): Wave {.RLAPI, importc: "LoadWave".} # Load wave data from file +proc LoadWaveFromMemory*(fileType: cstring; fileData: UncheckedArray[byte]; dataSize: int32): Wave {.RLAPI, importc: "LoadWaveFromMemory".} # Load wave from memory buffer, fileType refers to extension: i.e. '.wav' +proc LoadSound*(fileName: cstring): Sound {.RLAPI, importc: "LoadSound".} # Load sound from file +proc LoadSoundFromWave*(wave: Wave): Sound {.RLAPI, importc: "LoadSoundFromWave".} # Load sound from wave data +proc UpdateSound*(sound: Sound; data: pointer; samplesCount: int32) {.RLAPI, importc: "UpdateSound".} # Update sound buffer with new data +proc UnloadWave*(wave: Wave) {.RLAPI, importc: "UnloadWave".} # Unload wave data +proc UnloadSound*(sound: Sound) {.RLAPI, importc: "UnloadSound".} # Unload sound +proc ExportWave*(wave: Wave; fileName: cstring): bool {.RLAPI, importc: "ExportWave".} # Export wave data to file, returns true on success +proc ExportWaveAsCode*(wave: Wave; fileName: cstring): bool {.RLAPI, importc: "ExportWaveAsCode".} # Export wave sample data to code (.h), returns true on success +# Wave/Sound management functions +proc PlaySound*(sound: Sound) {.RLAPI, importc: "PlaySound".} # Play a sound +proc StopSound*(sound: Sound) {.RLAPI, importc: "StopSound".} # Stop playing a sound +proc PauseSound*(sound: Sound) {.RLAPI, importc: "PauseSound".} # Pause a sound +proc ResumeSound*(sound: Sound) {.RLAPI, importc: "ResumeSound".} # Resume a paused sound +proc PlaySoundMulti*(sound: Sound) {.RLAPI, importc: "PlaySoundMulti".} # Play a sound (using multichannel buffer pool) +proc StopSoundMulti*() {.RLAPI, importc: "StopSoundMulti".} # Stop any sound playing (using multichannel buffer pool) +proc GetSoundsPlaying*(): int32 {.RLAPI, importc: "GetSoundsPlaying".} # Get number of sounds playing in the multichannel +proc IsSoundPlaying*(sound: Sound): bool {.RLAPI, importc: "IsSoundPlaying".} # Check if a sound is currently playing +proc SetSoundVolume*(sound: Sound; volume: float32) {.RLAPI, importc: "SetSoundVolume".} # Set volume for a sound (1.0 is max level) +proc SetSoundPitch*(sound: Sound; pitch: float32) {.RLAPI, importc: "SetSoundPitch".} # Set pitch for a sound (1.0 is base level) +proc WaveFormat*(wave: ptr Wave; sampleRate: int32; sampleSize: int32; channels: int32) {.RLAPI, importc: "WaveFormat".} # Convert wave data to desired format +proc WaveCopy*(wave: Wave): Wave {.RLAPI, importc: "WaveCopy".} # Copy a wave to a new wave +proc WaveCrop*(wave: ptr Wave; initSample: int32; finalSample: int32) {.RLAPI, importc: "WaveCrop".} # Crop a wave to defined samples range +proc LoadWaveSamples*(wave: Wave): float32 {.RLAPI, importc: "LoadWaveSamples".} # Load samples data from wave as a floats array +proc UnloadWaveSamples*(samples: float32) {.RLAPI, importc: "UnloadWaveSamples".} # Unload samples data loaded with LoadWaveSamples() +# Music management functions +proc LoadMusicStream*(fileName: cstring): Music {.RLAPI, importc: "LoadMusicStream".} # Load music stream from file +proc LoadMusicStreamFromMemory*(fileType: cstring; data: uint8; dataSize: int32): Music {.RLAPI, importc: "LoadMusicStreamFromMemory".} # Load music stream from data +proc UnloadMusicStream*(music: Music) {.RLAPI, importc: "UnloadMusicStream".} # Unload music stream +proc PlayMusicStream*(music: Music) {.RLAPI, importc: "PlayMusicStream".} # Start music playing +proc IsMusicStreamPlaying*(music: Music): bool {.RLAPI, importc: "IsMusicStreamPlaying".} # Check if music is playing +proc UpdateMusicStream*(music: Music) {.RLAPI, importc: "UpdateMusicStream".} # Updates buffers for music streaming +proc StopMusicStream*(music: Music) {.RLAPI, importc: "StopMusicStream".} # Stop music playing +proc PauseMusicStream*(music: Music) {.RLAPI, importc: "PauseMusicStream".} # Pause music playing +proc ResumeMusicStream*(music: Music) {.RLAPI, importc: "ResumeMusicStream".} # Resume playing paused music +proc SetMusicVolume*(music: Music; volume: float32) {.RLAPI, importc: "SetMusicVolume".} # Set volume for music (1.0 is max level) +proc SetMusicPitch*(music: Music; pitch: float32) {.RLAPI, importc: "SetMusicPitch".} # Set pitch for a music (1.0 is base level) +proc GetMusicTimeLength*(music: Music): float32 {.RLAPI, importc: "GetMusicTimeLength".} # Get music time length (in seconds) +proc GetMusicTimePlayed*(music: Music): float32 {.RLAPI, importc: "GetMusicTimePlayed".} # Get current music time played (in seconds) +# AudioStream management functions +proc LoadAudioStream*(sampleRate: uint32; sampleSize: uint32; channels: uint32): AudioStream {.RLAPI, importc: "LoadAudioStream".} # Load audio stream (to stream raw audio pcm data) +proc UnloadAudioStream*(stream: AudioStream) {.RLAPI, importc: "UnloadAudioStream".} # Unload audio stream and free memory +proc UpdateAudioStream*(stream: AudioStream; data: pointer; samplesCount: int32) {.RLAPI, importc: "UpdateAudioStream".} # Update audio stream buffers with data +proc IsAudioStreamProcessed*(stream: AudioStream): bool {.RLAPI, importc: "IsAudioStreamProcessed".} # Check if any audio stream buffers requires refill +proc PlayAudioStream*(stream: AudioStream) {.RLAPI, importc: "PlayAudioStream".} # Play audio stream +proc PauseAudioStream*(stream: AudioStream) {.RLAPI, importc: "PauseAudioStream".} # Pause audio stream +proc ResumeAudioStream*(stream: AudioStream) {.RLAPI, importc: "ResumeAudioStream".} # Resume audio stream +proc IsAudioStreamPlaying*(stream: AudioStream): bool {.RLAPI, importc: "IsAudioStreamPlaying".} # Check if audio stream is playing +proc StopAudioStream*(stream: AudioStream) {.RLAPI, importc: "StopAudioStream".} # Stop audio stream +proc SetAudioStreamVolume*(stream: AudioStream; volume: float32) {.RLAPI, importc: "SetAudioStreamVolume".} # Set volume for audio stream (1.0 is max level) +proc SetAudioStreamPitch*(stream: AudioStream; pitch: float32) {.RLAPI, importc: "SetAudioStreamPitch".} # Set pitch for audio stream (1.0 is base level) +proc SetAudioStreamBufferSizeDefault*(size: int32) {.RLAPI, importc: "SetAudioStreamBufferSizeDefault".} # Default size for new audio streams +const GetImageData* = LoadImageColors +const KEY_MENU* = 82 \ No newline at end of file diff --git a/src/lsystempkg/raymath.nim b/src/lsystempkg/raymath.nim new file mode 100644 index 0000000..da30e88 --- /dev/null +++ b/src/lsystempkg/raymath.nim @@ -0,0 +1,270 @@ +# +# raymath v1.2 - Math functions to work with Vector3, Matrix and Quaternions +# +# CONFIGURATION: +# +# #define RAYMATH_IMPLEMENTATION +# Generates the implementation of the library into the included file. +# If not defined, the library is in header only mode and can be included in other headers +# or source files without problems. But only ONE file should hold the implementation. +# +# #define RAYMATH_HEADER_ONLY +# Define static inline functions code, so #include header suffices for use. +# This may use up lots of memory. +# +# #define RAYMATH_STANDALONE +# Avoid raylib.h header inclusion in this file. +# Vector3 and Matrix data types are defined internally in raymath module. +# +# +# LICENSE: zlib/libpng +# +# Copyright (c) 2015-2021 Ramon Santamaria (@raysan5) +# +# This software is provided "as-is", without any express or implied warranty. In no event +# will the authors be held liable for any damages arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, including commercial +# applications, and to alter it and redistribute it freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not claim that you +# wrote the original software. If you use this software in a product, an acknowledgment +# in the product documentation would be appreciated but is not required. +# +# 2. Altered source versions must be plainly marked as such, and must not be misrepresented +# as being the original software. +# +# 3. This notice may not be removed or altered from any source distribution. +# +template RAYMATH_H*(): auto = RAYMATH_H +# #define RAYMATH_STANDALONE +# #define RAYMATH_HEADER_ONLY +import raylib +{.pragma: RMDEF, cdecl, discardable, dynlib: "libraylib" & LEXT.} +# ---------------------------------------------------------------------------------- +# Defines and Macros +# ---------------------------------------------------------------------------------- +# Get float vector for Matrix +# Get float vector for Vector3 +# ---------------------------------------------------------------------------------- +# Types and Structures Definition +# ---------------------------------------------------------------------------------- +# NOTE: Helper types to be used instead of array return types for *ToFloat functions +type float3* {.bycopy.} = object + v*: array[0..2, float32] +type float16* {.bycopy.} = object + v*: array[0..15, float32] +# ---------------------------------------------------------------------------------- +# Module Functions Definition - Utils math +# ---------------------------------------------------------------------------------- +# Clamp float value +proc Clamp*(value: float32; min: float32; max: float32): float32 {.RMDEF, importc: "Clamp".} +# Calculate linear interpolation between two floats +proc Lerp*(start: float32; endx: float32; amount: float32): float32 {.RMDEF, importc: "Lerp".} +# Normalize input value within input range +proc Normalize*(value: float32; start: float32; endx: float32): float32 {.RMDEF, importc: "Normalize".} +# Remap input value within input range to output range +proc Remap*(value: float32; inputStart: float32; inputEnd: float32; outputStart: float32; outputEnd: float32): float32 {.RMDEF, importc: "Remap".} +# ---------------------------------------------------------------------------------- +# Module Functions Definition - Vector2 math +# ---------------------------------------------------------------------------------- +# Vector with components value 0.0f +proc Vector2Zero*(): Vector2 {.RMDEF, importc: "Vector2Zero".} +# Vector with components value 1.0f +proc Vector2One*(): Vector2 {.RMDEF, importc: "Vector2One".} +# Add two vectors (v1 + v2) +proc Vector2Add*(v1: Vector2; v2: Vector2): Vector2 {.RMDEF, importc: "Vector2Add".} +# Add vector and float value +proc Vector2AddValue*(v: Vector2; add: float32): Vector2 {.RMDEF, importc: "Vector2AddValue".} +# Subtract two vectors (v1 - v2) +proc Vector2Subtract*(v1: Vector2; v2: Vector2): Vector2 {.RMDEF, importc: "Vector2Subtract".} +# Subtract vector by float value +proc Vector2SubtractValue*(v: Vector2; sub: float32): Vector2 {.RMDEF, importc: "Vector2SubtractValue".} +# Calculate vector length +proc Vector2Length*(v: Vector2): float32 {.RMDEF, importc: "Vector2Length".} +# Calculate vector square length +proc Vector2LengthSqr*(v: Vector2): float32 {.RMDEF, importc: "Vector2LengthSqr".} +# Calculate two vectors dot product +proc Vector2DotProduct*(v1: Vector2; v2: Vector2): float32 {.RMDEF, importc: "Vector2DotProduct".} +# Calculate distance between two vectors +proc Vector2Distance*(v1: Vector2; v2: Vector2): float32 {.RMDEF, importc: "Vector2Distance".} +# Calculate angle from two vectors in X-axis +proc Vector2Angle*(v1: Vector2; v2: Vector2): float32 {.RMDEF, importc: "Vector2Angle".} +# Scale vector (multiply by value) +proc Vector2Scale*(v: Vector2; scale: float32): Vector2 {.RMDEF, importc: "Vector2Scale".} +# Multiply vector by vector +proc Vector2Multiply*(v1: Vector2; v2: Vector2): Vector2 {.RMDEF, importc: "Vector2Multiply".} +# Negate vector +proc Vector2Negate*(v: Vector2): Vector2 {.RMDEF, importc: "Vector2Negate".} +# Divide vector by vector +proc Vector2Divide*(v1: Vector2; v2: Vector2): Vector2 {.RMDEF, importc: "Vector2Divide".} +# Normalize provided vector +proc Vector2Normalize*(v: Vector2): Vector2 {.RMDEF, importc: "Vector2Normalize".} +# Calculate linear interpolation between two vectors +proc Vector2Lerp*(v1: Vector2; v2: Vector2; amount: float32): Vector2 {.RMDEF, importc: "Vector2Lerp".} +# Calculate reflected vector to normal +proc Vector2Reflect*(v: Vector2; normal: Vector2): Vector2 {.RMDEF, importc: "Vector2Reflect".} +# Rotate Vector by float in Degrees. +proc Vector2Rotate*(v: Vector2; degs: float32): Vector2 {.RMDEF, importc: "Vector2Rotate".} +# Move Vector towards target +proc Vector2MoveTowards*(v: Vector2; target: Vector2; maxDistance: float32): Vector2 {.RMDEF, importc: "Vector2MoveTowards".} +# ---------------------------------------------------------------------------------- +# Module Functions Definition - Vector3 math +# ---------------------------------------------------------------------------------- +# Vector with components value 0.0f +proc Vector3Zero*(): Vector3 {.RMDEF, importc: "Vector3Zero".} +# Vector with components value 1.0f +proc Vector3One*(): Vector3 {.RMDEF, importc: "Vector3One".} +# Add two vectors +proc Vector3Add*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3Add".} +# Add vector and float value +proc Vector3AddValue*(v: Vector3; add: float32): Vector3 {.RMDEF, importc: "Vector3AddValue".} +# Subtract two vectors +proc Vector3Subtract*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3Subtract".} +# Subtract vector by float value +proc Vector3SubtractValue*(v: Vector3; sub: float32): Vector3 {.RMDEF, importc: "Vector3SubtractValue".} +# Multiply vector by scalar +proc Vector3Scale*(v: Vector3; scalar: float32): Vector3 {.RMDEF, importc: "Vector3Scale".} +# Multiply vector by vector +proc Vector3Multiply*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3Multiply".} +# Calculate two vectors cross product +proc Vector3CrossProduct*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3CrossProduct".} +# Calculate one vector perpendicular vector +proc Vector3Perpendicular*(v: Vector3): Vector3 {.RMDEF, importc: "Vector3Perpendicular".} +# Calculate vector length +proc Vector3Length*(v: ptr Vector3): float32 {.RMDEF, importc: "Vector3Length".} +# Calculate vector square length +proc Vector3LengthSqr*(v: ptr Vector3): float32 {.RMDEF, importc: "Vector3LengthSqr".} +# Calculate two vectors dot product +proc Vector3DotProduct*(v1: Vector3; v2: Vector3): float32 {.RMDEF, importc: "Vector3DotProduct".} +# Calculate distance between two vectors +proc Vector3Distance*(v1: Vector3; v2: Vector3): float32 {.RMDEF, importc: "Vector3Distance".} +# Negate provided vector (invert direction) +proc Vector3Negate*(v: Vector3): Vector3 {.RMDEF, importc: "Vector3Negate".} +# Divide vector by vector +proc Vector3Divide*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3Divide".} +# Normalize provided vector +proc Vector3Normalize*(v: Vector3): Vector3 {.RMDEF, importc: "Vector3Normalize".} +# Orthonormalize provided vectors +# Makes vectors normalized and orthogonal to each other +# Gram-Schmidt function implementation +proc Vector3OrthoNormalize*(v1: ptr Vector3; v2: ptr Vector3) {.RMDEF, importc: "Vector3OrthoNormalize".} +# Transforms a Vector3 by a given Matrix +proc Vector3Transform*(v: Vector3; mat: Matrix): Vector3 {.RMDEF, importc: "Vector3Transform".} +# Transform a vector by quaternion rotation +proc Vector3RotateByQuaternion*(v: Vector3; q: Quaternion): Vector3 {.RMDEF, importc: "Vector3RotateByQuaternion".} +# Calculate linear interpolation between two vectors +proc Vector3Lerp*(v1: Vector3; v2: Vector3; amount: float32): Vector3 {.RMDEF, importc: "Vector3Lerp".} +# Calculate reflected vector to normal +proc Vector3Reflect*(v: Vector3; normal: Vector3): Vector3 {.RMDEF, importc: "Vector3Reflect".} +# Get min value for each pair of components +proc Vector3Min*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3Min".} +# Get max value for each pair of components +proc Vector3Max*(v1: Vector3; v2: Vector3): Vector3 {.RMDEF, importc: "Vector3Max".} +# Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c) +# NOTE: Assumes P is on the plane of the triangle +proc Vector3Barycenter*(p: Vector3; a: Vector3; b: Vector3; c: Vector3): Vector3 {.RMDEF, importc: "Vector3Barycenter".} +# Get Vector3 as float array +proc Vector3ToFloatV*(v: Vector3): float3 {.RMDEF, importc: "Vector3ToFloatV".} +# ---------------------------------------------------------------------------------- +# Module Functions Definition - Matrix math +# ---------------------------------------------------------------------------------- +# Compute matrix determinant +proc MatrixDeterminant*(mat: Matrix): float32 {.RMDEF, importc: "MatrixDeterminant".} +# Get the trace of the matrix (sum of the values along the diagonal) +proc MatrixTrace*(mat: Matrix): float32 {.RMDEF, importc: "MatrixTrace".} +# Transposes provided matrix +proc MatrixTranspose*(mat: Matrix): Matrix {.RMDEF, importc: "MatrixTranspose".} +# Invert provided matrix +proc MatrixInvert*(mat: Matrix): Matrix {.RMDEF, importc: "MatrixInvert".} +# Normalize provided matrix +proc MatrixNormalize*(mat: Matrix): Matrix {.RMDEF, importc: "MatrixNormalize".} +# Get identity matrix +proc MatrixIdentity*(): Matrix {.RMDEF, importc: "MatrixIdentity".} +# Add two matrices +proc MatrixAdd*(left: Matrix; right: Matrix): Matrix {.RMDEF, importc: "MatrixAdd".} +# Subtract two matrices (left - right) +proc MatrixSubtract*(left: Matrix; right: Matrix): Matrix {.RMDEF, importc: "MatrixSubtract".} +# Get two matrix multiplication +# NOTE: When multiplying matrices... the order matters! +proc MatrixMultiply*(left: Matrix; right: Matrix): Matrix {.RMDEF, importc: "MatrixMultiply".} +# Get translation matrix +proc MatrixTranslate*(x: float32; y: float32; z: float32): Matrix {.RMDEF, importc: "MatrixTranslate".} +# Create rotation matrix from axis and angle +# NOTE: Angle should be provided in radians +proc MatrixRotate*(axis: Vector3; angle: float32): Matrix {.RMDEF, importc: "MatrixRotate".} +# Get x-rotation matrix (angle in radians) +proc MatrixRotateX*(angle: float32): Matrix {.RMDEF, importc: "MatrixRotateX".} +# Get y-rotation matrix (angle in radians) +proc MatrixRotateY*(angle: float32): Matrix {.RMDEF, importc: "MatrixRotateY".} +# Get z-rotation matrix (angle in radians) +proc MatrixRotateZ*(angle: float32): Matrix {.RMDEF, importc: "MatrixRotateZ".} +# Get xyz-rotation matrix (angles in radians) +proc MatrixRotateXYZ*(ang: Vector3): Matrix {.RMDEF, importc: "MatrixRotateXYZ".} +# Get zyx-rotation matrix (angles in radians) +proc MatrixRotateZYX*(ang: Vector3): Matrix {.RMDEF, importc: "MatrixRotateZYX".} +# Get scaling matrix +proc MatrixScale*(x: float32; y: float32; z: float32): Matrix {.RMDEF, importc: "MatrixScale".} +# Get perspective projection matrix +proc MatrixFrustum*(left: float64; right: float64; bottom: float64; top: float64; near: float64; far: float64): Matrix {.RMDEF, importc: "MatrixFrustum".} +# Get perspective projection matrix +# NOTE: Angle should be provided in radians +proc MatrixPerspective*(fovy: float64; aspect: float64; near: float64; far: float64): Matrix {.RMDEF, importc: "MatrixPerspective".} +# Get orthographic projection matrix +proc MatrixOrtho*(left: float64; right: float64; bottom: float64; top: float64; near: float64; far: float64): Matrix {.RMDEF, importc: "MatrixOrtho".} +# Get camera look-at matrix (view matrix) +proc MatrixLookAt*(eye: Vector3; target: Vector3; up: Vector3): Matrix {.RMDEF, importc: "MatrixLookAt".} +# Get float array of matrix data +proc MatrixToFloatV*(mat: Matrix): float16 {.RMDEF, importc: "MatrixToFloatV".} +# ---------------------------------------------------------------------------------- +# Module Functions Definition - Quaternion math +# ---------------------------------------------------------------------------------- +# Add two quaternions +proc QuaternionAdd*(q1: Quaternion; q2: Quaternion): Quaternion {.RMDEF, importc: "QuaternionAdd".} +# Add quaternion and float value +proc QuaternionAddValue*(q: Quaternion; add: float32): Quaternion {.RMDEF, importc: "QuaternionAddValue".} +# Subtract two quaternions +proc QuaternionSubtract*(q1: Quaternion; q2: Quaternion): Quaternion {.RMDEF, importc: "QuaternionSubtract".} +# Subtract quaternion and float value +proc QuaternionSubtractValue*(q: Quaternion; sub: float32): Quaternion {.RMDEF, importc: "QuaternionSubtractValue".} +# Get identity quaternion +proc QuaternionIdentity*(): Quaternion {.RMDEF, importc: "QuaternionIdentity".} +# Computes the length of a quaternion +proc QuaternionLength*(q: Quaternion): float32 {.RMDEF, importc: "QuaternionLength".} +# Normalize provided quaternion +proc QuaternionNormalize*(q: Quaternion): Quaternion {.RMDEF, importc: "QuaternionNormalize".} +# Invert provided quaternion +proc QuaternionInvert*(q: Quaternion): Quaternion {.RMDEF, importc: "QuaternionInvert".} +# Calculate two quaternion multiplication +proc QuaternionMultiply*(q1: Quaternion; q2: Quaternion): Quaternion {.RMDEF, importc: "QuaternionMultiply".} +# Scale quaternion by float value +proc QuaternionScale*(q: Quaternion; mul: float32): Quaternion {.RMDEF, importc: "QuaternionScale".} +# Divide two quaternions +proc QuaternionDivide*(q1: Quaternion; q2: Quaternion): Quaternion {.RMDEF, importc: "QuaternionDivide".} +# Calculate linear interpolation between two quaternions +proc QuaternionLerp*(q1: Quaternion; q2: Quaternion; amount: float32): Quaternion {.RMDEF, importc: "QuaternionLerp".} +# Calculate slerp-optimized interpolation between two quaternions +proc QuaternionNlerp*(q1: Quaternion; q2: Quaternion; amount: float32): Quaternion {.RMDEF, importc: "QuaternionNlerp".} +# Calculates spherical linear interpolation between two quaternions +proc QuaternionSlerp*(q1: Quaternion; q2: Quaternion; amount: float32): Quaternion {.RMDEF, importc: "QuaternionSlerp".} +# Calculate quaternion based on the rotation from one vector to another +proc QuaternionFromVector3ToVector3*(fromx: Vector3; to: Vector3): Quaternion {.RMDEF, importc: "QuaternionFromVector3ToVector3".} +# Get a quaternion for a given rotation matrix +proc QuaternionFromMatrix*(mat: Matrix): Quaternion {.RMDEF, importc: "QuaternionFromMatrix".} +# Get a matrix for a given quaternion +proc QuaternionToMatrix*(q: Quaternion): Matrix {.RMDEF, importc: "QuaternionToMatrix".} +# Get rotation quaternion for an angle and axis +# NOTE: angle must be provided in radians +proc QuaternionFromAxisAngle*(axis: Vector3; angle: float32): Quaternion {.RMDEF, importc: "QuaternionFromAxisAngle".} +# Get the rotation angle and axis for a given quaternion +proc QuaternionToAxisAngle*(q: Quaternion; outAxis: ptr Vector3; outAngle: float32) {.RMDEF, importc: "QuaternionToAxisAngle".} +# Get the quaternion equivalent to Euler angles +# NOTE: Rotation order is ZYX +proc QuaternionFromEuler*(pitch: float32; yaw: float32; roll: float32): Quaternion {.RMDEF, importc: "QuaternionFromEuler".} +# Get the Euler angles equivalent to quaternion (roll, pitch, yaw) +# NOTE: Angles are returned in a Vector3 struct in degrees +proc QuaternionToEuler*(q: Quaternion): Vector3 {.RMDEF, importc: "QuaternionToEuler".} +# Transform a quaternion given a transformation matrix +proc QuaternionTransform*(q: Quaternion; mat: Matrix): Quaternion {.RMDEF, importc: "QuaternionTransform".} +# Projects a Vector3 from screen space into object space +proc Vector3Unproject*(source: Vector3; projection: Matrix; view: Matrix): Vector3 {.RMDEF, importc: "Vector3Unproject".} \ No newline at end of file diff --git a/src/lsystempkg/rlgl.nim b/src/lsystempkg/rlgl.nim new file mode 100644 index 0000000..f7b011a --- /dev/null +++ b/src/lsystempkg/rlgl.nim @@ -0,0 +1,318 @@ +# +# rlgl v3.7 - raylib OpenGL abstraction layer +# +# rlgl is a wrapper for multiple OpenGL versions (1.1, 2.1, 3.3 Core, ES 2.0) to +# pseudo-OpenGL 1.1 style functions (rlVertex, rlTranslate, rlRotate...). +# +# When chosing an OpenGL version greater than OpenGL 1.1, rlgl stores vertex data on internal +# VBO buffers (and VAOs if available). It requires calling 3 functions: +# rlglInit() - Initialize internal buffers and auxiliary resources +# rlglClose() - De-initialize internal buffers data and other auxiliar resources +# +# CONFIGURATION: +# +# #define GRAPHICS_API_OPENGL_11 +# #define GRAPHICS_API_OPENGL_21 +# #define GRAPHICS_API_OPENGL_33 +# #define GRAPHICS_API_OPENGL_ES2 +# Use selected OpenGL graphics backend, should be supported by platform +# Those preprocessor defines are only used on rlgl module, if OpenGL version is +# required by any other module, use rlGetVersion() to check it +# +# #define RLGL_IMPLEMENTATION +# Generates the implementation of the library into the included file. +# If not defined, the library is in header only mode and can be included in other headers +# or source files without problems. But only ONE file should hold the implementation. +# +# #define RLGL_STANDALONE +# Use rlgl as standalone library (no raylib dependency) +# +# #define SUPPORT_GL_DETAILS_INFO +# Show OpenGL extensions and capabilities detailed logs on init +# +# DEPENDENCIES: +# raymath - 3D math functionality (Vector3, Matrix, Quaternion) +# GLAD - OpenGL extensions loading (OpenGL 3.3 Core only) +# +# +# LICENSE: zlib/libpng +# +# Copyright (c) 2014-2021 Ramon Santamaria (@raysan5) +# +# This software is provided "as-is", without any express or implied warranty. In no event +# will the authors be held liable for any damages arising from the use of this software. +# +# Permission is granted to anyone to use this software for any purpose, including commercial +# applications, and to alter it and redistribute it freely, subject to the following restrictions: +# +# 1. The origin of this software must not be misrepresented; you must not claim that you +# wrote the original software. If you use this software in a product, an acknowledgment +# in the product documentation would be appreciated but is not required. +# +# 2. Altered source versions must be plainly marked as such, and must not be misrepresented +# as being the original software. +# +# 3. This notice may not be removed or altered from any source distribution. +# +template RLGL_H*(): auto = RLGL_H +{.pragma: RLAPI, cdecl, discardable, dynlib: "libraylib" & LEXT.} +import raylib +# Security check in case no GRAPHICS_API_OPENGL_* defined +# Security check in case multiple GRAPHICS_API_OPENGL_* defined +# OpenGL 2.1 uses most of OpenGL 3.3 Core functionality +# WARNING: Specific parts are checked with #if defines +template SUPPORT_RENDER_TEXTURES_HINT*(): auto = SUPPORT_RENDER_TEXTURES_HINT +# ---------------------------------------------------------------------------------- +# Defines and Macros +# ---------------------------------------------------------------------------------- +# Default internal render batch limits +# Internal Matrix stack +# Vertex buffers id limit +# Shader and material limits +# Projection matrix culling +# Texture parameters (equivalent to OpenGL defines) +template RL_TEXTURE_WRAP_S*(): auto = 0x2802 +template RL_TEXTURE_WRAP_T*(): auto = 0x2803 +template RL_TEXTURE_MAG_FILTER*(): auto = 0x2800 +template RL_TEXTURE_MIN_FILTER*(): auto = 0x2801 +template RL_TEXTURE_FILTER_NEAREST*(): auto = 0x2600 +template RL_TEXTURE_FILTER_LINEAR*(): auto = 0x2601 +template RL_TEXTURE_FILTER_MIP_NEAREST*(): auto = 0x2700 +template RL_TEXTURE_FILTER_NEAREST_MIP_LINEAR*(): auto = 0x2702 +template RL_TEXTURE_FILTER_LINEAR_MIP_NEAREST*(): auto = 0x2701 +template RL_TEXTURE_FILTER_MIP_LINEAR*(): auto = 0x2703 +template RL_TEXTURE_FILTER_ANISOTROPIC*(): auto = 0x3000 +template RL_TEXTURE_WRAP_REPEAT*(): auto = 0x2901 +template RL_TEXTURE_WRAP_CLAMP*(): auto = 0x812F +template RL_TEXTURE_WRAP_MIRROR_REPEAT*(): auto = 0x8370 +template RL_TEXTURE_WRAP_MIRROR_CLAMP*(): auto = 0x8742 +# Matrix modes (equivalent to OpenGL) +template RL_MODELVIEW*(): auto = 0x1700 +template RL_PROJECTION*(): auto = 0x1701 +template RL_TEXTURE*(): auto = 0x1702 +# Primitive assembly draw modes +template RL_LINES*(): auto = 0x0001 +template RL_TRIANGLES*(): auto = 0x0004 +template RL_QUADS*(): auto = 0x0007 +# GL equivalent data types +template RL_UNSIGNED_BYTE*(): auto = 0x1401 +template RL_FLOAT*(): auto = 0x1406 +# ---------------------------------------------------------------------------------- +# Types and Structures Definition +# ---------------------------------------------------------------------------------- +type FramebufferAttachType* = enum + RL_ATTACHMENT_COLOR_CHANNEL0 = 0 + RL_ATTACHMENT_COLOR_CHANNEL1 + RL_ATTACHMENT_COLOR_CHANNEL2 + RL_ATTACHMENT_COLOR_CHANNEL3 + RL_ATTACHMENT_COLOR_CHANNEL4 + RL_ATTACHMENT_COLOR_CHANNEL5 + RL_ATTACHMENT_COLOR_CHANNEL6 + RL_ATTACHMENT_COLOR_CHANNEL7 + RL_ATTACHMENT_DEPTH = 100 + RL_ATTACHMENT_STENCIL = 200 +converter FramebufferAttachType2int32* (self: FramebufferAttachType): int32 = self.int32 +type FramebufferAttachTextureType* = enum + RL_ATTACHMENT_CUBEMAP_POSITIVE_X = 0 + RL_ATTACHMENT_CUBEMAP_NEGATIVE_X + RL_ATTACHMENT_CUBEMAP_POSITIVE_Y + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Y + RL_ATTACHMENT_CUBEMAP_POSITIVE_Z + RL_ATTACHMENT_CUBEMAP_NEGATIVE_Z + RL_ATTACHMENT_TEXTURE2D = 100 + RL_ATTACHMENT_RENDERBUFFER = 200 +converter FramebufferAttachTextureType2int32* (self: FramebufferAttachTextureType): int32 = self.int32 +# Dynamic vertex buffers (position + texcoords + colors + indices arrays) +type VertexBuffer* {.bycopy.} = object + elementsCount*: int32 # Number of elements in the buffer (QUADS) + vCounter*: int32 # Vertex position counter to process (and draw) from full buffer + tcCounter*: int32 # Vertex texcoord counter to process (and draw) from full buffer + cCounter*: int32 # Vertex color counter to process (and draw) from full buffer + vertices*: float32 # Vertex position (XYZ - 3 components per vertex) (shader-location = 0) + texcoords*: float32 # Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1) + colors*: uint8 # Vertex colors (RGBA - 4 components per vertex) (shader-location = 3) + indices*: uint32 # Vertex indices (in case vertex data comes indexed) (6 indices per quad) + # Skipped another *indices + vaoId*: uint32 # OpenGL Vertex Array Object id + vboId*: array[0..3, uint32] # OpenGL Vertex Buffer Objects id (4 types of vertex data) +# Draw call type +# NOTE: Only texture changes register a new draw, other state-change-related elements are not +# used at this moment (vaoId, shaderId, matrices), raylib just forces a batch draw call if any +# of those state-change happens (this is done in core module) +type DrawCall* {.bycopy.} = object + mode*: int32 # Drawing mode: LINES, TRIANGLES, QUADS + vertexCount*: int32 # Number of vertex of the draw + vertexAlignment*: int32 # Number of vertex required for index alignment (LINES, TRIANGLES) + textureId*: uint32 # Texture id to be used on the draw -> Use to create new draw call if changes +# RenderBatch type +type RenderBatch* {.bycopy.} = object + buffersCount*: int32 # Number of vertex buffers (multi-buffering support) + currentBuffer*: int32 # Current buffer tracking in case of multi-buffering + vertexBuffer*: ptr VertexBuffer # Dynamic buffer(s) for vertex data + draws*: ptr DrawCall # Draw calls array, depends on textureId + drawsCounter*: int32 # Draw calls counter + currentDepth*: float32 # Current depth value for next draw +# ------------------------------------------------------------------------------------ +# Functions Declaration - Matrix operations +# ------------------------------------------------------------------------------------ +proc rlMatrixMode*(mode: int32) {.RLAPI, importc: "rlMatrixMode".} # Choose the current matrix to be transformed +proc rlPushMatrix*() {.RLAPI, importc: "rlPushMatrix".} # Push the current matrix to stack +proc rlPopMatrix*() {.RLAPI, importc: "rlPopMatrix".} # Pop lattest inserted matrix from stack +proc rlLoadIdentity*() {.RLAPI, importc: "rlLoadIdentity".} # Reset current matrix to identity matrix +proc rlTranslatef*(x: float32; y: float32; z: float32) {.RLAPI, importc: "rlTranslatef".} # Multiply the current matrix by a translation matrix +proc rlRotatef*(angleDeg: float32; x: float32; y: float32; z: float32) {.RLAPI, importc: "rlRotatef".} # Multiply the current matrix by a rotation matrix +proc rlScalef*(x: float32; y: float32; z: float32) {.RLAPI, importc: "rlScalef".} # Multiply the current matrix by a scaling matrix +proc rlMultMatrixf*(matf: float32) {.RLAPI, importc: "rlMultMatrixf".} # Multiply the current matrix by another matrix +proc rlFrustum*(left: float64; right: float64; bottom: float64; top: float64; znear: float64; zfar: float64) {.RLAPI, importc: "rlFrustum".} +proc rlOrtho*(left: float64; right: float64; bottom: float64; top: float64; znear: float64; zfar: float64) {.RLAPI, importc: "rlOrtho".} +proc rlViewport*(x: int32; y: int32; width: int32; height: int32) {.RLAPI, importc: "rlViewport".} # Set the viewport area +# ------------------------------------------------------------------------------------ +# Functions Declaration - Vertex level operations +# ------------------------------------------------------------------------------------ +proc rlBegin*(mode: int32) {.RLAPI, importc: "rlBegin".} # Initialize drawing mode (how to organize vertex) +proc rlEnd*() {.RLAPI, importc: "rlEnd".} # Finish vertex providing +proc rlVertex2i*(x: int32; y: int32) {.RLAPI, importc: "rlVertex2i".} # Define one vertex (position) - 2 int +proc rlVertex2f*(x: float32; y: float32) {.RLAPI, importc: "rlVertex2f".} # Define one vertex (position) - 2 float +proc rlVertex3f*(x: float32; y: float32; z: float32) {.RLAPI, importc: "rlVertex3f".} # Define one vertex (position) - 3 float +proc rlTexCoord2f*(x: float32; y: float32) {.RLAPI, importc: "rlTexCoord2f".} # Define one vertex (texture coordinate) - 2 float +proc rlNormal3f*(x: float32; y: float32; z: float32) {.RLAPI, importc: "rlNormal3f".} # Define one vertex (normal) - 3 float +proc rlColor4ub*(r: uint8; g: uint8; b: uint8; a: uint8) {.RLAPI, importc: "rlColor4ub".} # Define one vertex (color) - 4 byte +proc rlColor3f*(x: float32; y: float32; z: float32) {.RLAPI, importc: "rlColor3f".} # Define one vertex (color) - 3 float +proc rlColor4f*(x: float32; y: float32; z: float32; w: float32) {.RLAPI, importc: "rlColor4f".} # Define one vertex (color) - 4 float +# ------------------------------------------------------------------------------------ +# Functions Declaration - OpenGL style functions (common to 1.1, 3.3+, ES2) +# NOTE: This functions are used to completely abstract raylib code from OpenGL layer, +# some of them are direct wrappers over OpenGL calls, some others are custom +# ------------------------------------------------------------------------------------ +# Vertex buffers state +proc rlEnableVertexArray*(vaoId: uint32): bool {.RLAPI, importc: "rlEnableVertexArray".} # Enable vertex array (VAO, if supported) +proc rlDisableVertexArray*() {.RLAPI, importc: "rlDisableVertexArray".} # Disable vertex array (VAO, if supported) +proc rlEnableVertexBuffer*(id: uint32) {.RLAPI, importc: "rlEnableVertexBuffer".} # Enable vertex buffer (VBO) +proc rlDisableVertexBuffer*() {.RLAPI, importc: "rlDisableVertexBuffer".} # Disable vertex buffer (VBO) +proc rlEnableVertexBufferElement*(id: uint32) {.RLAPI, importc: "rlEnableVertexBufferElement".} # Enable vertex buffer element (VBO element) +proc rlDisableVertexBufferElement*() {.RLAPI, importc: "rlDisableVertexBufferElement".} # Disable vertex buffer element (VBO element) +proc rlEnableVertexAttribute*(index: uint32) {.RLAPI, importc: "rlEnableVertexAttribute".} # Enable vertex attribute index +proc rlDisableVertexAttribute*(index: uint32) {.RLAPI, importc: "rlDisableVertexAttribute".} # Disable vertex attribute index +proc rlEnableStatePointer*(vertexAttribType: int32; buffer: pointer) {.RLAPI, importc: "rlEnableStatePointer".} +proc rlDisableStatePointer*(vertexAttribType: int32) {.RLAPI, importc: "rlDisableStatePointer".} +# Textures state +proc rlActiveTextureSlot*(slot: int32) {.RLAPI, importc: "rlActiveTextureSlot".} # Select and active a texture slot +proc rlEnableTexture*(id: uint32) {.RLAPI, importc: "rlEnableTexture".} # Enable texture +proc rlDisableTexture*() {.RLAPI, importc: "rlDisableTexture".} # Disable texture +proc rlEnableTextureCubemap*(id: uint32) {.RLAPI, importc: "rlEnableTextureCubemap".} # Enable texture cubemap +proc rlDisableTextureCubemap*() {.RLAPI, importc: "rlDisableTextureCubemap".} # Disable texture cubemap +proc rlTextureParameters*(id: uint32; param: int32; value: int32) {.RLAPI, importc: "rlTextureParameters".} # Set texture parameters (filter, wrap) +# Shader state +proc rlEnableShader*(id: uint32) {.RLAPI, importc: "rlEnableShader".} # Enable shader program +proc rlDisableShader*() {.RLAPI, importc: "rlDisableShader".} # Disable shader program +# Framebuffer state +proc rlEnableFramebuffer*(id: uint32) {.RLAPI, importc: "rlEnableFramebuffer".} # Enable render texture (fbo) +proc rlDisableFramebuffer*() {.RLAPI, importc: "rlDisableFramebuffer".} # Disable render texture (fbo), return to default framebuffer +# General render state +proc rlEnableDepthTest*() {.RLAPI, importc: "rlEnableDepthTest".} # Enable depth test +proc rlDisableDepthTest*() {.RLAPI, importc: "rlDisableDepthTest".} # Disable depth test +proc rlEnableDepthMask*() {.RLAPI, importc: "rlEnableDepthMask".} # Enable depth write +proc rlDisableDepthMask*() {.RLAPI, importc: "rlDisableDepthMask".} # Disable depth write +proc rlEnableBackfaceCulling*() {.RLAPI, importc: "rlEnableBackfaceCulling".} # Enable backface culling +proc rlDisableBackfaceCulling*() {.RLAPI, importc: "rlDisableBackfaceCulling".} # Disable backface culling +proc rlEnableScissorTest*() {.RLAPI, importc: "rlEnableScissorTest".} # Enable scissor test +proc rlDisableScissorTest*() {.RLAPI, importc: "rlDisableScissorTest".} # Disable scissor test +proc rlScissor*(x: int32; y: int32; width: int32; height: int32) {.RLAPI, importc: "rlScissor".} # Scissor test +proc rlEnableWireMode*() {.RLAPI, importc: "rlEnableWireMode".} # Enable wire mode +proc rlDisableWireMode*() {.RLAPI, importc: "rlDisableWireMode".} # Disable wire mode +proc rlSetLineWidth*(width: float32) {.RLAPI, importc: "rlSetLineWidth".} # Set the line drawing width +proc rlGetLineWidth*(): float32 {.RLAPI, importc: "rlGetLineWidth".} # Get the line drawing width +proc rlEnableSmoothLines*() {.RLAPI, importc: "rlEnableSmoothLines".} # Enable line aliasing +proc rlDisableSmoothLines*() {.RLAPI, importc: "rlDisableSmoothLines".} # Disable line aliasing +proc rlEnableStereoRender*() {.RLAPI, importc: "rlEnableStereoRender".} # Enable stereo rendering +proc rlDisableStereoRender*() {.RLAPI, importc: "rlDisableStereoRender".} # Disable stereo rendering +proc rlIsStereoRenderEnabled*(): bool {.RLAPI, importc: "rlIsStereoRenderEnabled".} # Check if stereo render is enabled +proc rlClearColor*(r: uint8; g: uint8; b: uint8; a: uint8) {.RLAPI, importc: "rlClearColor".} # Clear color buffer with color +proc rlClearScreenBuffers*() {.RLAPI, importc: "rlClearScreenBuffers".} # Clear used screen buffers (color and depth) +proc rlCheckErrors*() {.RLAPI, importc: "rlCheckErrors".} # Check and log OpenGL error codes +proc rlSetBlendMode*(mode: int32) {.RLAPI, importc: "rlSetBlendMode".} # Set blending mode +proc rlSetBlendFactors*(glSrcFactor: int32; glDstFactor: int32; glEquation: int32) {.RLAPI, importc: "rlSetBlendFactors".} # Set blending mode factor and equation (using OpenGL factors) +# ------------------------------------------------------------------------------------ +# Functions Declaration - rlgl functionality +# ------------------------------------------------------------------------------------ +# rlgl initialization functions +proc rlglInit*(width: int32; height: int32) {.RLAPI, importc: "rlglInit".} # Initialize rlgl (buffers, shaders, textures, states) +proc rlglClose*() {.RLAPI, importc: "rlglClose".} # De-inititialize rlgl (buffers, shaders, textures) +proc rlLoadExtensions*(loader: pointer) {.RLAPI, importc: "rlLoadExtensions".} # Load OpenGL extensions (loader function required) +proc rlGetVersion*(): int32 {.RLAPI, importc: "rlGetVersion".} # Get current OpenGL version +proc rlGetFramebufferWidth*(): int32 {.RLAPI, importc: "rlGetFramebufferWidth".} # Get default framebuffer width +proc rlGetFramebufferHeight*(): int32 {.RLAPI, importc: "rlGetFramebufferHeight".} # Get default framebuffer height +proc rlGetShaderDefault*(): Shader {.RLAPI, importc: "rlGetShaderDefault".} # Get default shader +proc rlGetTextureDefault*(): Texture2D {.RLAPI, importc: "rlGetTextureDefault".} # Get default texture +# Render batch management +# NOTE: rlgl provides a default render batch to behave like OpenGL 1.1 immediate mode +# but this render batch API is exposed in case of custom batches are required +proc rlLoadRenderBatch*(numBuffers: int32; bufferElements: int32): RenderBatch {.RLAPI, importc: "rlLoadRenderBatch".} # Load a render batch system +proc rlUnloadRenderBatch*(batch: RenderBatch) {.RLAPI, importc: "rlUnloadRenderBatch".} # Unload render batch system +proc rlDrawRenderBatch*(batch: ptr RenderBatch) {.RLAPI, importc: "rlDrawRenderBatch".} # Draw render batch data (Update->Draw->Reset) +proc rlSetRenderBatchActive*(batch: ptr RenderBatch) {.RLAPI, importc: "rlSetRenderBatchActive".} # Set the active render batch for rlgl (NULL for default internal) +proc rlDrawRenderBatchActive*() {.RLAPI, importc: "rlDrawRenderBatchActive".} # Update and draw internal render batch +proc rlCheckRenderBatchLimit*(vCount: int32): bool {.RLAPI, importc: "rlCheckRenderBatchLimit".} # Check internal buffer overflow for a given number of vertex +proc rlSetTexture*(id: uint32) {.RLAPI, importc: "rlSetTexture".} # Set current texture for render batch and check buffers limits +# ------------------------------------------------------------------------------------------------------------------------ +# Vertex buffers management +proc rlLoadVertexArray*(): uint32 {.RLAPI, importc: "rlLoadVertexArray".} # Load vertex array (vao) if supported +proc rlLoadVertexBuffer*(buffer: pointer; size: int32; dynamic: bool): uint32 {.RLAPI, importc: "rlLoadVertexBuffer".} # Load a vertex buffer attribute +proc rlLoadVertexBufferElement*(buffer: pointer; size: int32; dynamic: bool): uint32 {.RLAPI, importc: "rlLoadVertexBufferElement".} # Load a new attributes element buffer +proc rlUpdateVertexBuffer*(bufferId: int32; data: pointer; dataSize: int32; offset: int32) {.RLAPI, importc: "rlUpdateVertexBuffer".} # Update GPU buffer with new data +proc rlUnloadVertexArray*(vaoId: uint32) {.RLAPI, importc: "rlUnloadVertexArray".} +proc rlUnloadVertexBuffer*(vboId: uint32) {.RLAPI, importc: "rlUnloadVertexBuffer".} +proc rlSetVertexAttribute*(index: uint32; compSize: int32; typex: int32; normalized: bool; stride: int32; pointer: pointer) {.RLAPI, importc: "rlSetVertexAttribute".} +proc rlSetVertexAttributeDivisor*(index: uint32; divisor: int32) {.RLAPI, importc: "rlSetVertexAttributeDivisor".} +proc rlSetVertexAttributeDefault*(locIndex: int32; value: pointer; attribType: int32; count: int32) {.RLAPI, importc: "rlSetVertexAttributeDefault".} # Set vertex attribute default value +proc rlDrawVertexArray*(offset: int32; count: int32) {.RLAPI, importc: "rlDrawVertexArray".} +proc rlDrawVertexArrayElements*(offset: int32; count: int32; buffer: pointer) {.RLAPI, importc: "rlDrawVertexArrayElements".} +proc rlDrawVertexArrayInstanced*(offset: int32; count: int32; instances: int32) {.RLAPI, importc: "rlDrawVertexArrayInstanced".} +proc rlDrawVertexArrayElementsInstanced*(offset: int32; count: int32; buffer: pointer; instances: int32) {.RLAPI, importc: "rlDrawVertexArrayElementsInstanced".} +# Textures management +proc rlLoadTexture*(data: pointer; width: int32; height: int32; format: int32; mipmapCount: int32): uint32 {.RLAPI, importc: "rlLoadTexture".} # Load texture in GPU +proc rlLoadTextureDepth*(width: int32; height: int32; useRenderBuffer: bool): uint32 {.RLAPI, importc: "rlLoadTextureDepth".} # Load depth texture/renderbuffer (to be attached to fbo) +proc rlLoadTextureCubemap*(data: pointer; size: int32; format: int32): uint32 {.RLAPI, importc: "rlLoadTextureCubemap".} # Load texture cubemap +proc rlUpdateTexture*(id: uint32; offsetX: int32; offsetY: int32; width: int32; height: int32; format: int32; data: pointer) {.RLAPI, importc: "rlUpdateTexture".} # Update GPU texture with new data +proc rlGetGlTextureFormats*(format: int32; glInternalFormat: uint32; glFormat: uint32; glType: uint32) {.RLAPI, importc: "rlGetGlTextureFormats".} # Get OpenGL internal formats +proc rlGetPixelFormatName*(format: uint32): cstring {.RLAPI, importc: "rlGetPixelFormatName".} # Get name string for pixel format +proc rlUnloadTexture*(id: uint32) {.RLAPI, importc: "rlUnloadTexture".} # Unload texture from GPU memory +proc rlGenerateMipmaps*(texture: ptr Texture2D) {.RLAPI, importc: "rlGenerateMipmaps".} # Generate mipmap data for selected texture +proc rlReadTexturePixels*(texture: Texture2D): pointer {.RLAPI, importc: "rlReadTexturePixels".} # Read texture pixel data +proc rlReadScreenPixels*(width: int32; height: int32): uint8 {.RLAPI, importc: "rlReadScreenPixels".} # Read screen pixel data (color buffer) +# Framebuffer management (fbo) +proc rlLoadFramebuffer*(width: int32; height: int32): uint32 {.RLAPI, importc: "rlLoadFramebuffer".} # Load an empty framebuffer +proc rlFramebufferAttach*(fboId: uint32; texId: uint32; attachType: int32; texType: int32; mipLevel: int32) {.RLAPI, importc: "rlFramebufferAttach".} # Attach texture/renderbuffer to a framebuffer +proc rlFramebufferComplete*(id: uint32): bool {.RLAPI, importc: "rlFramebufferComplete".} # Verify framebuffer is complete +proc rlUnloadFramebuffer*(id: uint32) {.RLAPI, importc: "rlUnloadFramebuffer".} # Delete framebuffer from GPU +# Shaders management +proc rlLoadShaderCode*(vsCode: cstring; fsCode: cstring): uint32 {.RLAPI, importc: "rlLoadShaderCode".} # Load shader from code strings +proc rlCompileShader*(shaderCode: cstring; typex: int32): uint32 {.RLAPI, importc: "rlCompileShader".} # Compile custom shader and return shader id (type: GL_VERTEX_SHADER, GL_FRAGMENT_SHADER) +proc rlLoadShaderProgram*(vShaderId: uint32; fShaderId: uint32): uint32 {.RLAPI, importc: "rlLoadShaderProgram".} # Load custom shader program +proc rlUnloadShaderProgram*(id: uint32) {.RLAPI, importc: "rlUnloadShaderProgram".} # Unload shader program +proc rlGetLocationUniform*(shaderId: uint32; uniformName: cstring): int32 {.RLAPI, importc: "rlGetLocationUniform".} # Get shader location uniform +proc rlGetLocationAttrib*(shaderId: uint32; attribName: cstring): int32 {.RLAPI, importc: "rlGetLocationAttrib".} # Get shader location attribute +proc rlSetUniform*(locIndex: int32; value: pointer; uniformType: int32; count: int32) {.RLAPI, importc: "rlSetUniform".} # Set shader value uniform +proc rlSetUniformMatrix*(locIndex: int32; mat: Matrix) {.RLAPI, importc: "rlSetUniformMatrix".} # Set shader value matrix +proc rlSetUniformSampler*(locIndex: int32; textureId: uint32) {.RLAPI, importc: "rlSetUniformSampler".} # Set shader value sampler +proc rlSetShader*(shader: Shader) {.RLAPI, importc: "rlSetShader".} # Set shader currently active +# Matrix state management +proc rlGetMatrixModelview*(): Matrix {.RLAPI, importc: "rlGetMatrixModelview".} # Get internal modelview matrix +proc rlGetMatrixProjection*(): Matrix {.RLAPI, importc: "rlGetMatrixProjection".} # Get internal projection matrix +proc rlGetMatrixTransform*(): Matrix {.RLAPI, importc: "rlGetMatrixTransform".} # Get internal accumulated transform matrix +proc rlGetMatrixProjectionStereo*(eye: int32): Matrix {.RLAPI, importc: "rlGetMatrixProjectionStereo".} # Get internal projection matrix for stereo render (selected eye) +proc rlGetMatrixViewOffsetStereo*(eye: int32): Matrix {.RLAPI, importc: "rlGetMatrixViewOffsetStereo".} # Get internal view offset matrix for stereo render (selected eye) +proc rlSetMatrixProjection*(proj: Matrix) {.RLAPI, importc: "rlSetMatrixProjection".} # Set a custom projection matrix (replaces internal projection matrix) +proc rlSetMatrixModelview*(view: Matrix) {.RLAPI, importc: "rlSetMatrixModelview".} # Set a custom modelview matrix (replaces internal modelview matrix) +proc rlSetMatrixProjectionStereo*(right: Matrix; left: Matrix) {.RLAPI, importc: "rlSetMatrixProjectionStereo".} # Set eyes projection matrices for stereo rendering +proc rlSetMatrixViewOffsetStereo*(right: Matrix; left: Matrix) {.RLAPI, importc: "rlSetMatrixViewOffsetStereo".} # Set eyes view offsets matrices for stereo rendering +# Quick and dirty cube/quad buffers load->draw->unload +proc rlLoadDrawCube*() {.RLAPI, importc: "rlLoadDrawCube".} # Load and draw a cube +proc rlLoadDrawQuad*() {.RLAPI, importc: "rlLoadDrawQuad".} # Load and draw a quad +# +# RLGL IMPLEMENTATION +# +type rlglLoadProc* = proc() +# ---------------------------------------------------------------------------------- +# Global Variables Definition +# ---------------------------------------------------------------------------------- \ No newline at end of file diff --git a/styles/README.md b/styles/README.md new file mode 100644 index 0000000..2b07017 --- /dev/null +++ b/styles/README.md @@ -0,0 +1,36 @@ +## raygui styles + +`raygui` comes with **8 custom styles** carefully designed for the best visual experience. Those styles have been created using [rGuiStyler](https://raylibtech.itch.io/rguistyler) tool and they complement internal [default style](default), always available by `raygui`. + +To use those styles with your `raygui` development, just need to call `GuiLoadStyle()` function at initialization, passing the `.rgs` file to load. Note that most of those styles depend on custom fonts that must be available together with the `.rgs` file. + +Here it is a quick overview of those styles, you can navigate to each directory for additional information. + +#### style: [default](default) +![default style](default/style_table.png) + +#### style: [ashes](ashes) +![ashes style](ashes/style_table.png) + +#### style: [bluish](bluish) +![bluish style](bluish/style_table.png) + +#### style: [candy](candy) +![candy style](candy/style_table.png) + +#### style: [cherry](cherry) +![cherry style](cherry/style_table.png) + +#### style: [cyber](cyber) +![cyber style](cyber/style_table.png) + +#### style: [jungle](jungle) +![jungle style](jungle/style_table.png) + +#### style: [lavanda](lavanda) +![lavanda style](lavanda/style_table.png) + +#### style: [terminal](terminal) +![terminal style](terminal/style_table.png) + +*NOTE: Those styles require latest raylib 2.6-dev and latest raygui 2.6-dev.* diff --git a/styles/ashes/README.md b/styles/ashes/README.md new file mode 100644 index 0000000..dc8adc0 --- /dev/null +++ b/styles/ashes/README.md @@ -0,0 +1,16 @@ +style: ashes +------------- +What once was life now is ashes, just as slight reminiscense covers the ground, a gray sequence of tones that reminds to a distant past. + +![ashes style table](style_table.png) + +screenshot +----------- + +![ashes style screen](screenshot.png) + +about font +----------- +"V5 Loxica Lixera" font by vFive Digital (Roberto Christen). + +100% free font, downloaded from dafont.com: [v5loxica-lixera](https://www.dafont.com/v5loxica-lixera.font) diff --git a/styles/ashes/ashes.rgs b/styles/ashes/ashes.rgs new file mode 100644 index 0000000..45ab7bd --- /dev/null +++ b/styles/ashes/ashes.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 16 0 v5loxical.ttf +p 00 00 0xf0f0f0ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0x868686ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0xe6e6e6ff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0x929999ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0xeaeaeaff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0x98a1a8ff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0x3f3f3fff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0xf6f6f6ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0x414141ff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x8b8b8bff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0x777777ff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x959595ff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x00000010 TEXT_SIZE +p 00 17 0x00000001 TEXT_SPACING +p 00 18 0x9dadb1ff DEFAULT_LINE_COLOR +p 00 19 0x6b6b6bff DEFAULT_BACKGROUND_COLOR diff --git a/styles/ashes/font_readme.txt b/styles/ashes/font_readme.txt new file mode 100644 index 0000000..1a6b338 --- /dev/null +++ b/styles/ashes/font_readme.txt @@ -0,0 +1,51 @@ + +V5 Loxica +--------------- +Instructions: + + +++ Loxica (LIXERA) ++ + +For screen use, set at 16pt. Turn +antialiasing off. Set tracking to zero +for best results. + +++ Loxica (ROBUSTA) ++ + +For screen use, set at 18pt. Turn +antialiasing off. Set tracking to zero +for best results. + + +Notes: + +1. These faces do not contain any hinting +information since they were built for use +at the sizes listed above. Naturally, for +print use you are free to experiment. + +2. Although the intended size for _lixera_ +is 16pt (vs. 18pt for _robusta_), they share +the same optical size (where lixera is the +regular weight, and robusta is the bold). + +3. Pronounciation: "lo-hee-ka lee-he-ra", and +"lo-hee-ka ro-bus-ta." + + + +--------------- +Usage: This is a free font--you may use +this and other V5 fonts at will. It may not +be sold, altered, or improperly credited, +however. All I ask is that you kindly inform +me if you find this font useful, and where +you've used it. + +Enjoy, + +©2000 +Roberto Christen +rob@vfive.com + + diff --git a/styles/ashes/screenshot.png b/styles/ashes/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..f86859a2b949d7598072abb69e897a5836e73a2f GIT binary patch literal 42971 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 X|F+NycsuY`a*)La8`C0V_e1{!(^m8B literal 0 HcmV?d00001 diff --git a/styles/ashes/v5loxical.ttf b/styles/ashes/v5loxical.ttf new file mode 100644 index 0000000000000000000000000000000000000000..61501cbc0431ed3a5d7a1581acfc80743d20b59d GIT binary patch literal 26384 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 literal 0 HcmV?d00001 diff --git a/styles/bluish/README.md b/styles/bluish/README.md new file mode 100644 index 0000000..1057dde --- /dev/null +++ b/styles/bluish/README.md @@ -0,0 +1,16 @@ +style: bluish +-------------- +Like a breeze, a slight touch of color cover the clear sky, a spacious and relaxing feeling. + +![bluish style table](style_table.png) + +screenshot +----------- + +![bluish style screen](screenshot.png) + +about font +----------- +"Homespun BRK" font by AEnigma (Brian Kent). + +100% free font, downloaded from dafont.com: [homespun-brk](https://www.dafont.com/homespun-brk.font) diff --git a/styles/bluish/bluish.rgs b/styles/bluish/bluish.rgs new file mode 100644 index 0000000..9a2b7c4 --- /dev/null +++ b/styles/bluish/bluish.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 10 0 homespun.ttf +p 00 00 0x5ca6a6ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0xb4e8f3ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0x447e77ff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0x5f8792ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0xcdeff7ff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0x4c6c74ff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0x3b5b5fff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0xeaffffff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0x275057ff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x96aaacff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0xc8d7d9ff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x8c9c9eff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x0000000a TEXT_SIZE +p 00 17 0x00000001 TEXT_SPACING +p 00 18 0x84adb7ff DEFAULT_LINE_COLOR +p 00 19 0xe8eef1ff DEFAULT_BACKGROUND_COLOR diff --git a/styles/bluish/font_readme.txt b/styles/bluish/font_readme.txt new file mode 100644 index 0000000..8dd9bdc --- /dev/null +++ b/styles/bluish/font_readme.txt @@ -0,0 +1,76 @@ +_______________________________ +Homespun Created by Brian Kent +¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ +Thanks for Downloading Homespun. + +Homespun TT [.ttf] +Homespun [8pt] [.fon] + + + 'homespun.fon' is a Windows Bitmap Font (.fon). This font is best +used at 8pt. To use it at larger point sizes (for images), try using +a graphics program like Photoshop, Paint Shop Pro, or the Paint +program that comes with Windows. Type out your text at the recommended +point size [8pt], then resize the image. Set the color mode to 256 +or 2 colors so the edges don't get blured when resizing, then after you +have the text to the size that you want, then change back to a higher +color mode and edit the image. + + For programs that don't show Bitmap Fonts in the Font Selector, you +may be able to get the font to work by typing in: +homespun brk + + When using the TTF version, try using it with anti-aliasing off. + + +If you have any questions or comments, you can e-mail me at +kentpw@norwich.net + +You can visit my Webpage <ÆNIGMA GAMES & FONTS> at +http://www.aenigmafonts.com/ + +________________ +INSTALLING FONTS +¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯ + There's a couple of ways to install Fonts. The 'easy' way to +install fonts is to just Unzip/place the font file [.ttf] into your +Windows\Fonts directory (I always use this method). If you're unable +to do it the 'easy' way, then try to do it this way (for Windows +95/98/NT): + +1] Unzip the Font(s) to a folder (or somewhere, just remember where +you unzipped it) on your Computer. + +2] Next, click on the START button, then select SETTINGS then +CONTROL PANEL. + +3] When the Control Panel Window pops up, Double Click on FONTS. + +4] When the FONTS window pops up, select File then Install New Font... + +5] A Add Fonts window will pop up, just go to the folder that you +unzipped the Font(s) to, select the Font(s) and then click on OK. +Now the Font(s) are installed. + + Now you can use the Font(s) in programs that utilize Fonts. Make +sure that you install the font(s) first, then open up your apps +(so the app will recognize the font). Sometimes you'll have to +wait until your computer 'auto-refreshes' for programs to recognize +fonts (Windows is sometimes slow to do that). You can refresh your +computer quicker by going into Windows Explorer -or- My Computer and +press F5 (or in the menubar select VIEW then REFRESH). + + +__________ +DISCLAIMER +¯¯¯¯¯¯¯¯¯¯ +-The font(s) in this zip file were created by me (Brian Kent). All +of my Fonts are Freeware, you can use them any way you want to +(Personal use, Commercial use, or whatever). + +-If you have a Font related site and would like to offer my fonts on +your site, go right ahead. All I ask is that you keep this text file +intact with the Font. + +-You may not Sell or Distribute my Fonts for profit or alter them in +any way without asking me first. [e-mail - kentpw@norwich.net] diff --git a/styles/bluish/homespun.ttf b/styles/bluish/homespun.ttf new file mode 100644 index 0000000000000000000000000000000000000000..45c23e0147d681b989aa1ccff56a9c3b140c0225 GIT binary patch literal 16040 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 UF5N*kgMfbywyrkiR)mxP1I6JSPXGV_ literal 0 HcmV?d00001 diff --git a/styles/bluish/style_table.png b/styles/bluish/style_table.png new file mode 100644 index 0000000000000000000000000000000000000000..6889f6c86f293b6aa3f2966566ad7397444579cd GIT binary patch literal 27222 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 IB{lm00d)|4v;Y7A literal 0 HcmV?d00001 diff --git a/styles/candy/README.md b/styles/candy/README.md new file mode 100644 index 0000000..3442189 --- /dev/null +++ b/styles/candy/README.md @@ -0,0 +1,16 @@ +style: candy +------------- +Sweet, colorful, tasty! Enjoy this funfair ride and be careful with the witch of the candy house! + +![candy style table](style_table.png) + +screenshot +----------- + +![candy style screen](screenshot.png) + +about font +----------- +"V5 Eastergothic" font by vFive Digital (Roberto Christen). + +100% free font, downloaded from dafont.com: [v5eastergothic](https://www.dafont.com/v5eastergothic.font) diff --git a/styles/candy/candy.rgs b/styles/candy/candy.rgs new file mode 100644 index 0000000..0ba56a7 --- /dev/null +++ b/styles/candy/candy.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 15 0 v5easter.ttf +p 00 00 0xe58b68ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0xfeda96ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0xe59b5fff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0xee813fff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0xfcd85bff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0xfc6955ff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0xb34848ff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0xeb7272ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0xbd4a4aff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x94795dff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0xc2a37aff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x9c8369ff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x0000000f TEXT_SIZE +p 00 17 0x00000001 TEXT_SPACING +p 00 18 0xd77575ff DEFAULT_LINE_COLOR +p 00 19 0xfff5e1ff DEFAULT_BACKGROUND_COLOR diff --git a/styles/candy/font_readme.txt b/styles/candy/font_readme.txt new file mode 100644 index 0000000..cfd8cb2 --- /dev/null +++ b/styles/candy/font_readme.txt @@ -0,0 +1,27 @@ + +V5 Easter Gothic +---------------- +Instructions: + + +++ Easter Gothic ++ + +For screen use, set at 15pt or any multiple +of 15 (display). Turn antialiasing off. Set +tracking to 100 for best results. + +--------------- +Usage: This is a free font--you may use +this and other V5 fonts at will. It may not +be sold, altered, or improperly credited, +however. All I ask is that you kindly inform +me if you find this font useful, and where +you've used it. + +Enjoy, + +©2000 +Roberto Christen +rob@vfive.com + + diff --git a/styles/candy/screenshot.png b/styles/candy/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..e84aef3111bf0e530aeb854ffa08f82d3455d2fe GIT binary patch literal 60853 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

qSLW6L%SGnTTYl2l_!NJ3N`Cxk&6 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 HJ@)?rDCahB literal 0 HcmV?d00001 diff --git a/styles/candy/v5easter.ttf b/styles/candy/v5easter.ttf new file mode 100644 index 0000000000000000000000000000000000000000..77a911a617ef05d6dab3d342f38fa87e8f9678f0 GIT binary patch literal 27140 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 literal 0 HcmV?d00001 diff --git a/styles/cherry/README.md b/styles/cherry/README.md new file mode 100644 index 0000000..eb9f3d1 --- /dev/null +++ b/styles/cherry/README.md @@ -0,0 +1,16 @@ +style: cherry +-------------- +Sweet with a touch of liquour, covered in chocolate, just give it a try! Not suitable for every palate, only the most demanding. + +![cherry style table](style_table.png) + +screenshot +----------- + +![cherry style screen](screenshot.png) + +about font +----------- +"Westington" font by Hazel Abbiati. + +100% free font, downloaded from dafont.com: [westington](https://www.dafont.com/westington.font) diff --git a/styles/cherry/Westington.ttf b/styles/cherry/Westington.ttf new file mode 100644 index 0000000000000000000000000000000000000000..68efae80709c391be864b2280f98d8c484395f29 GIT binary patch literal 49360 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 a6*>O?8^7@vs537;HnN4sm+!m#xBefeUUj7a literal 0 HcmV?d00001 diff --git a/styles/cherry/cherry.rgs b/styles/cherry/cherry.rgs new file mode 100644 index 0000000..a830816 --- /dev/null +++ b/styles/cherry/cherry.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 15 0 Westington.ttf +p 00 00 0xda5757ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0x753233ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0xe17373ff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0xfaaa97ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0xe06262ff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0xfdb4aaff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0xe03c46ff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0x5b1e20ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0xc2474fff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0xa19292ff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0x706060ff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x9e8585ff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x0000000f TEXT_SIZE +p 00 17 0x00000000 TEXT_SPACING +p 00 18 0xfb8170ff DEFAULT_LINE_COLOR +p 00 19 0x3a1720ff DEFAULT_BACKGROUND_COLOR diff --git a/styles/cherry/screenshot.png b/styles/cherry/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..669a40bd8d576ed0012cd03cd44e2d8c303ca05d GIT binary patch literal 66058 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 literal 0 HcmV?d00001 diff --git a/styles/default/style_table.png b/styles/default/style_table.png new file mode 100644 index 0000000000000000000000000000000000000000..191a14ff14671e5aae8f3e71c1f0f086d700b09b GIT binary patch literal 23916 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 Gj{QF?iv^(o literal 0 HcmV?d00001 diff --git a/styles/jungle/Pixel Intv.otf b/styles/jungle/Pixel Intv.otf new file mode 100644 index 0000000000000000000000000000000000000000..e8c54a79531b7fe61d47cfe391c8bf61ac48352c GIT binary patch literal 19892 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 ZAW0whq##fJ*5IBfWa{=K@Uzt-{{w_%t@8i? literal 0 HcmV?d00001 diff --git a/styles/jungle/README.md b/styles/jungle/README.md new file mode 100644 index 0000000..a08b6fc --- /dev/null +++ b/styles/jungle/README.md @@ -0,0 +1,16 @@ +style: jungle +-------------- +Sunset in the jungle, trees do not let to see the last rays of sun on the horizon, small creek in the path, mug on the shoes, a touch of danger and the adventure feeling, get into your jeep and drive with this style. + +![jungle style table](style_table.png) + +screenshot +----------- + +![jungle style screen](screenshot.png) + +about font +----------- +"Pixel Intv" font by [Pixel Sagas](http://www.pixelsagas.com) (Neale and Shayna Davidson). + +100% free font, downloaded from dafont.com: [pixel-intv](https://www.dafont.com/pixel-intv.font) diff --git a/styles/jungle/font_readme.txt b/styles/jungle/font_readme.txt new file mode 100644 index 0000000..b4e6c6e --- /dev/null +++ b/styles/jungle/font_readme.txt @@ -0,0 +1,47 @@ +Shareware/ Font License + +Pixel Sagas Freeware Fonts EULA (End User License Agreement) and Software Inclusion Agreement + +"Purchaser" and "User" may be used interchangeably in this agreement. + +"Pixel Sagas" and "Neale Davidson" may be used interchangeably in this agreement. These all refer to the intellectual and legal property of Neale Davidson. + +Usage + +Pixel Saga's Shareware Fonts are free to use for personal, non-commercial purposes. No payment is necessary to use Pixel Saga's Freeware Fonts for personal use, and there is no limit to the amount of prints, pages, or other medium to be produced using them. However, you cannot offer the font for commercial sale, or offer for direct download. The inclusion othe font name and/or site URL in the credits or documentation when it is used is appreciated, but this is not mandatory. + +Payment + +Payment is not required for the use of Pixel Saga's Shareware Fonts. Commercial use requires a modest fee which can be paid through the pixelsagas.com web site through Paypal.com's services. The transaction receipt for any shareware "commercial license" purchase will suffice as proof of license. + +Support + +Font installation help is available at http://www.pixelsagas.com. If you experience problems with any Pixel Saga's Freeware font (such as spacing issues or missing characters), please verify that you have the correct and current version of the fonts. In the case of Freeware fonts, downloading the font directly from the Pixel Sagas site will ensure that the font files have not been altered. + +Software Inclusion Agreement + +Pixel Saga's software products are protected by copyright laws and International copyright treaties, as well as other intellectual property laws and treaties. All Pixel Saga's software products are licensed, not sold. + +1) GRANT OF LICENSE + +This document grants the user the following rights: + +Installation and Use. The user may install and use an unlimited number of copies of the software product. The user may not offer Pixel Sagas freeware fonts for direct download unless the user has received explicit, written permission from Neale Davidson. Otherwise please direct users to the http://www.pixelsagas.com website. Pixel Sagas freeware fonts may, however, be embedded for web, publication, or general software use. + +2) WARRANTIES + +None + +Pixel Sagas expressly disclaims any warranty for the software product. The software product and any related documentation is provided "as is" without warranty of any kind, either express or implied, including, without limitation, the implied warranties or merchantability, fitness for a particular purpose, or non-infringement. The entire risk arising out of use or performance of the software product remains with the user. + +No Liability For Consequential Damages. + +In no event shall Neale Davidson or Pixel Sagas be liable for any damages whatsoever (including, without limitation, damages for loss of business profits, business interruption, loss of business information, or any other pecuniary loss) arising out of the use of or inability to use this product, even if Pixel Sagas has been advised of the possibility of such damages. + +3) MISCELLANEOUS + +Should the user have any questions concerning this document or you desire to contact Neale Davidson for any reason, please email jaynz@pixelsagas.com . + +Governing Law + +This agreement is governed by and subject to the laws of the United States of America. diff --git a/styles/jungle/jungle.rgs b/styles/jungle/jungle.rgs new file mode 100644 index 0000000..1852268 --- /dev/null +++ b/styles/jungle/jungle.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 12 0 Pixel Intv.otf +p 00 00 0x60827dff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0x2c3334ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0x82a29fff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0x5f9aa8ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0x334e57ff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0x6aa9b8ff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0xa9cb8dff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0x3b6357ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0x97af81ff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x5b6462ff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0x2c3334ff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x666b69ff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x0000000c TEXT_SIZE +p 00 17 0x00000000 TEXT_SPACING +p 00 18 0x638465ff DEFAULT_LINE_COLOR +p 00 19 0x2b3a3aff DEFAULT_BACKGROUND_COLOR diff --git a/styles/jungle/screenshot.png b/styles/jungle/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..bc6afef07cad5bc4b8e08629576c0ace188ec7b8 GIT binary patch literal 54542 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 Mor`U;jo0b_1M*f#?EnA( literal 0 HcmV?d00001 diff --git a/styles/jungle/style_table.png b/styles/jungle/style_table.png new file mode 100644 index 0000000000000000000000000000000000000000..17d5f96bae528ca60e3a069e80be08cc2290fbbd GIT binary patch literal 24692 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 Z&Hv`O^nCY-j!#@Bgd!{Xc#^Pt5=T literal 0 HcmV?d00001 diff --git a/styles/lavanda/README.md b/styles/lavanda/README.md new file mode 100644 index 0000000..396dfc5 --- /dev/null +++ b/styles/lavanda/README.md @@ -0,0 +1,16 @@ +style: lavanda +--------------- +Walk thought the fields full of lavanda, feels like a dream, a touch of fantasy, just relax and close your eyes, could you feel it? + +![lavanda style table](style_table.png) + +screenshot +----------- + +![lavanda style screen](screenshot.png) + +about font +----------- +"Cartridge" font by [jeti](https://fontenddev.com/) + +Licensed under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), downloaded from dafont.com: [cartridge](https://www.dafont.com/cartridge.font) diff --git a/styles/lavanda/font_readme.txt b/styles/lavanda/font_readme.txt new file mode 100644 index 0000000..c9ff454 --- /dev/null +++ b/styles/lavanda/font_readme.txt @@ -0,0 +1,6 @@ +Cartridge by jeti: A decorative, Art Nouveau-inspired font with a dainty, fantastical hand-lettered feel. + +You are free to use this font for personal or commercial projects, all I ask is that you include credit. + +Licensed under CC BY 4.0: https://creativecommons.org/licenses/by/4.0/ +More info: https://fontenddev.com/fonts/cartridge/ diff --git a/styles/lavanda/lavanda.rgs b/styles/lavanda/lavanda.rgs new file mode 100644 index 0000000..23de947 --- /dev/null +++ b/styles/lavanda/lavanda.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 16 0 Cartridge.ttf +p 00 00 0xab9bd3ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0x3e4350ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0xdadaf4ff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0xee84a0ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0xf4b7c7ff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0xb7657bff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0xd5c8dbff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0x966ec0ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0xd7ccf7ff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x8fa2bdff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0x6b798dff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x8292a9ff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x00000010 TEXT_SIZE +p 00 17 0x00000001 TEXT_SPACING +p 00 18 0x84adb7ff DEFAULT_LINE_COLOR +p 00 19 0x5b5b81ff DEFAULT_BACKGROUND_COLOR diff --git a/styles/lavanda/screenshot.png b/styles/lavanda/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..d6b621caed50899d03382914efa1fe343e096f71 GIT binary patch literal 66412 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

^k*G_}-7$dI!kdR2w&TUh!i1Bk(^%I2@jE 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�)^$PRs6kp&Kz|E11wRqv{qDg5fY2Bft^{ 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 literal 0 HcmV?d00001 diff --git a/styles/terminal/Mecha.ttf b/styles/terminal/Mecha.ttf new file mode 100644 index 0000000000000000000000000000000000000000..dd564a8fa2e09a6db6181d04c2f07648344c4f86 GIT binary patch literal 105740 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 literal 0 HcmV?d00001 diff --git a/styles/terminal/README.md b/styles/terminal/README.md new file mode 100644 index 0000000..6b10d2d --- /dev/null +++ b/styles/terminal/README.md @@ -0,0 +1,16 @@ +style: terminal +---------------- +Start your terminal and type your commands! Feel the connection the data flow, that's your style! + +![terminal style table](style_table.png) + +screenshot +----------- + +![terminal style screen](screenshot.png) + +about font +----------- +"Mecha" font by Captain Falcon. + +100% free font, downloaded from dafont.com: [mecha-cf](https://www.dafont.com/mecha-cf.font) diff --git a/styles/terminal/screenshot.png b/styles/terminal/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..7b8562b5176f563519111f50a52e4d069495855f GIT binary patch literal 50850 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 literal 0 HcmV?d00001 diff --git a/styles/terminal/style_table.png b/styles/terminal/style_table.png new file mode 100644 index 0000000000000000000000000000000000000000..7b527b2d01a366c450bb67f3900fcb0171bcb587 GIT binary patch literal 23465 zcmeHvc|4SB|NmHGWH6Q(Gh-RDRWum;nyIm5OPz91#y(_^mPthzWX4Xmif)ODs7X{h zM3zDZ$yU)!Mbe=tZTj6qPMwzL>GYi6>-&7auj7w--7~lQnrr(k@6Y>vO@h6xxxiB7 zQV0YhU}>?|0RrLihCnzVP#*A;(u&qD2*f$qa_yQ;ySI6;guUM1!Y(D?i8$_`d?875 zS_5u|NKOEQ{ka#@V{pWgY)Kp6pKsyhLJNNXv@k!D|IEWb`+;qXrvKQ*yifXXnTIq{ zO%eU2%a;hLJh9Y59ma=ATXnBm+Nzb86^LxF{7L5(gC|Q5E0PFm?ANUi`5N%$=>(iq8?6R*wNk}b{#2{F_{iAJ9mjhG5e`G<9kxUTbstbA5<=RLN1 z=Oe0jBLj{Qi2CaVefn`{L-v^w z!`!`bCw_Ji6v&Z<7E1qVVSXn6*Uv+w7p^GI96ChaAB0qpv7oDUUo!mH*3@7l~A9sxQ z=saj`s=S2mI-*b%1E=q_h4!e6p*=!E*1okJ^$-l zAiw@Vasc)~M-4N)tK~k3oi>uy3**anvSJ1I>mcvKJg;+w?v`s-DtjQbB^N<6Sqtqn zc-q?D46XwXA8G&Q__`cZJ5BTMhn<2P4qZy;?51wJj*cbgSG8JLZ;94YBW*AjjGdK= zui{W0n3~4zz}+`9iyWGhSoN-iaX?<@UdRO*!Z`U&EQH*Tr|D;AJg17iEhkDIE-?SF z6L-YnsC228F%Eg3z7o~h471=HU%9&pHfAKPmFp^rC`r9PdRI;A)XdyyV;d>U5bgC`;264PRVZ^Gt{j6gEt^~?WalCvXEtJ6ew8tczJf7L zq?-z8T28!6F0LGrN<#?KF4=JO!FDCVxN4Nq4S)JFou5OHV3HTM zG>Vas!zj}J+go^Q2B8Nat1kS?duyu?u)*YuFTml6^l}-S8a#%Z&^=byBvRXO0CzQR zXAKT{0GL@?iziMeBRpsdc>;q^L=H%7)$u#3B;{7-0JC1(y9t_7F-(*DUicY7>Eqpu$Z#=<6x zbs|FWfqLr5`#rRvhybzBfaB}(_R+URHS$zWs5@mWrN`f?cOuhl+pyGwQGy&Sicujo z`OMC+0@@|@IB6kZ#Ngdc9@cHy(W}>$;#55e-8WlKt&dl|Xvw!M!V6yWFkLY0B(-BS zDaS3-lyMW~6!v^F(-)Xgkkb=*R4seLdQFEc-e|vX&d$mU0`USqE^aUprK%SK4h9a) zaOGtWSdTEFGqm2BXp?Yzc^mt|!>lR+^X{=>o1obzCZRVI7_-F_*`iw3C)Zu}p>J~| z%JwuhOFWC#+Qz$mOpBZ$*`WMof)$8~92()#Li?)kHp%t-!h7+kaf7><(W4_~M#LQv z^k2m=cxTSsOFFzBn9^}N+iAc}Q1T{p5B=qQ0rD#bdkGPU8=+Dl;BvD)=a=98MOVJ{ zwnZ?C(VD|()I@R?#nz32sgDXp4HLOP23Gl4_<;eL=U5JFKqoDoOU2EG7K}979A8yR z8=6J8?*KA6S8fC&x`3}#NxXphJPadjkPRJ#v5sBsf+f{_f{2S!v{ zQtvN7O&HxqHvwAR{E2vG5DAz#O3B&;1w@5-02x6Y?|pZjVr73_pk ztN7wJ=N`Nu$-Ckn;jJX#)wz)5O?Qow@@Y+y>KJV2j7+V2!sfZ6m)YIyp6*?&>ng*d zTm!BFZn{vj$g(FBB*U*EdL(FndBLRR#?#vJwM<%u_BgnsR6BX(xGgLJfS<`@j#ThU z+ru{7{0*noOm7V~XsH%F=5>md(Q@cwf142)8>6w@1k^AWN(JD02VB4QS9~U<%xpeZ z(*I`-I*I|b5z+@f^*mmP!%A(xlo4>)xYY-jMBqR5)#`j1Zv>)7L^uIaO~7~0=O{H2 zW7@&ZuaLe3h_WR^sZ9*hDakKP${JHJoqc%Z=+nmxi!bj9aHQdhEw*i7(%Lln6fE@+ z)%|YNufp{DXJ1M^D!wMf)Yh@n`93Kp3dvcJw1k`u?`G8XVk9SuI+emxQ9i6ofw*l6 zLV6M5!p0k+x7~WmeOgp^@t%6uC~jOmWTt$E;^!z7mQS;_5G?QIQWwnv-4E!40=C^S zBVs3#PIwI_5ABq$9R#MWZeb4y8%$}qG(_3&2Hxf!75!!UNglPQT0!URhVx}s)L-#s zCYnx4qB5MLA&G6xcMhXU-3$>;+bK@@0%6$#V^W$eTxz3|X%2c3Ia0^^fhA8tgP4Jv z23mM*k4$Qs9A3)d7@E^d$Nbw+Ou<`1hO&;U_#PwV~1oQh7(^pH>LxKK`EAYC_dK)#>CUd|bFpG~&drr;QNE3V8c~LrWe3iZe zde1uhN3Y6xKfXn@Va{G#>U{6y&V;4g2h(<_LaKli(`OAAyN?X*G%{)5I%0t z&*A?34e5-Cs}Eyu^JDffo)qnc7HkQtUSXfoV3CTV-G~z4@Q;V_cIE;hfbNB_RYNpao}NN*>9Vw8;c3 zjPLM~*-Q9=u}FOo4fFykzMs5>E(KDvFTPM)C3^L<(b^k3aY_swZi*k${8+x^nfGs_ zkVKhQuDAF?*cw;d*=XkM<5b;_`0WqE3z*@$jgm$;TiI^RS(8hIlVux7vwcEU>;s4F z0%oKuf`hN~)_5&H!7om5zgo1;F}XJcPQ#@OiqE+R`BxLB&amK8?>YQ5Q73nfg3uqK$5=m}-$TlOKF_N=EpF2fK zkLPCH6e$fQz~KjWz=|1Nc%O2*EYVOBe@ki=m)GwkwS`;uNAo59RorB6w6X!<^Tmiq zAVG%*Cp0dJdgGkugWWJcN7bo|00*vdA@@vM21ei9Tk|P5&ju*!%+rqqodTHR(LW2E6d=@Y}yMXHuB-uq-aUtLk~ zP^xVkwV1hR^ideoXMX2LkedMWCfHoI6b)b;Cx89e0VuWSi20ug6;>>yn^ZKPzLVD*nzZuNy zilge$L4dCx-9_>#2218;b*=}%_&)uBx;ebw!jeC_MokK2;maO_^9g6;%%%9%dPzwj#5L@IB0ATXh;1HZCy85l_Cl$}48~LoR2OCJuNUrp@4 z9@?k7qhj+(lx4s_EwGcx|7;$phR4r*XuU8Ff^b0i=TmI?72G|`Gh1G+=0Aa1m+%l6 z%OGPQxywf{O6z?8mFf0SwzmIQcH^^+uQMMosuov(_wBCl(wJ(x)+|&h*ZK z=|c)muhR!SY}q?}Vv!dG-5D~;lS&zpg+}q@Ndi+}Ym2zVIe~y{g{iZhgVgCH9fyH4 zZ0}}@iigW8(2~@sD70@zhUFtLo{~cdWtSjEK|*)vkw;}n%l7wxh!*^|88GL8U4tV6 zB8B{msDhKp;{2cD{|{Wz!J4xHSQ+g7rqBHm7Q9nszP9)|+Wd=cv0DH`q|IlNA9-VL z<(k>>Y3jB&%a5@`WXV^n^GA~O2Tw&=zYroHE`~_#WDaVPode1bMG7?%}vC1fwtp>N`fp!eO_N7TXVAS5A%2;n0A33Tm~j-Kl); zb%S25T%453T+zj=3=J+VZc{1#X)LA~h$_Qt3|JQ0J(1JtXbHbdx*{SII{QQ}q8NUv zp=4`vit{tUO|KJFBZ6yU?HvVfS4fZQqK>4XUCMaf6<3)v{Xvdw@JdE(9dSTv{mm+w znh8VlMf0)Dqi%C@J0EyeQ@9Ez39odFlunJ_){!g?Ss%C!@OI8boToS)@TS`;mf6{K z=uTJ&Fzd0~qL0cXNIA=t=%Plks4fHVNrCDD9~Tx>ahH9fS zfUmzmC&Lltf`KHS%>ho&@OX7KZjl(-F=>(0C<9B?1|jTqvx=DCN#R(i8F3=9eeGqC z(Bm;rQ&8w2B;P=zL$nb}+Pq9b+DKm<*CPwdL_4e+6ITFEDKSIef6P(sKsibB3JXS4-Fe5{c_>XPi75 zm76aKCJ61X!-O~@%$p<8(P}}ajl$so!{RO6bahe1)SB|Tsx;`HExec3CxDpH^|=|u z`Jr`tb)C-~DSt$W!|b7~@m*F%YEhpKSqvgKJto;JVPSYY9GCn#2@WAcQwCl}k2PNu zjqIw@$LI*$J|YfWzMXLM!042nuPe7R`Cv^PcDt!KhPepM^gj=lY?;9_# zjlB>c5Pu~Ua^F&O)Z1;x%9@Fn4ADTscvqn`XCrHd;i!1EbflM zH0KgMs#p!91lNM-t}YMz$X0D}jKQH+-lT5OM1^VEN z6$K~zM=9-u_=g$Hk(x=$agfk@+wrCWlGRsrqD3!?c!M#umEqJ5rdkWdrqt<>G%r>A z&pvuonB5d&(*dj6Z%l#-XgjXIwPrBt+%9^DyefCakyQ{)4n0A0r)t4RZ@f#IC5@DP zC=(Aq^mL?*rmOZiNg0Undqzlx(GMbL!P%S8)YsF@WfR^YvrsFcPi5h>KqRYhWtHPU&fh9nvqtCvv?iRNpub2 zJB{O}aSg%on&hl>z&wXm<;}C4yXEdRef?6+Tq5{&!C;Phs;+*S3@a;j)Jucx;fK5L zMuDhaBh!;mpKD3MK@rm>@m>xdVb8sA$!VbFU}!>FeD)CmTT_NitA)ek)A)FRi2PPsGY%w+oP`81qN znaBcy&6Vn9tYyPjJvMx$ba&)1HW?r}E8qxg-w5pVVDN=-w{-b}VBj&U&9vVj7Y{P( zxfrbDt`69BN9p*`P&RNjT&yJuBROYxUZy^ak!%;A4@R@|{^BzLdw1^XFvye42j{gQ zuy^*x>3z~)!J0r3WPYLHW*)!i}x9%;eS(?{JieM;l2VYkrpNKvqcnp2%G^1Sxwz869HE?|0ujW=Y z2A2%D(i|pZC9l%gCRQk3yjQd<_f^I@8P#iXj$moCzjOULFh6i=17UZ>#A+*vJN5$- zb&sB<(uaMDs%TR)3c)A5$S1Wt-?mt$vo7r_%JQz*sd{xv+x@M4Uz?fG7Kb;R0j;)4 zK8}bf-ls>Y0g?vP4v`XQ@2efS6hDYA^_vC%xRF{2#BwCoW zvDX#kSFokt^nL1v0}_B&$1q5|MQBG1OaTG2g~Eqh0tohR58j(1_~(Vo4rwFYgG;83 zC_C<2Ss|siT3~e@IIFITl!FjxA>kk|t(`-a`*P@+*q>KB;n~Kw<z;%T{b1)XXPK{mWPLI;iG0k`=fK*C0463~UMVK3|29f17^nUf`DwE##R3982-U zFu4F6-{)cB4_P6|f_NhlZByF0#e|!g_0pWcE>po;oIcVAzq*6;iv%@;j?EtLVmo;9 zejGQuv~#ZzJDtV^NfL3)pQdtgw!t(qhlgj!6GbQE|&w1e$zp2_~x4a&}oF@W~Md{ z3H~3>*&`h?9F22rOC>l9EYC5j5l$+8Y^IA3yFkJQZ7=~z*xSRlzW`I3AV;0Gmk#Dd z5!zt=@I^mpHd$PNFL7bxl$|E*7-KWA0z?YrMBe84^!%5f?&E)pcA0%b<1>))7svBo zG76%kz}S42RxiqVEl>_%sK=WPPn7F$Z`A~Oq?N5AqCP+lTXXOSE}Fk8k(!5^nZ?9_ zrl>;~8T*?^lDK(A!h+)gLI~DSSlD~>vyR6zO-hX(;XoT1kp39SL3d{A#rJ`P5IhL4 z7JU(dlm4Q4@NJzL5tKFHL}bW$sbGk)$_vNY(8Nhx!kmC_*yxGNU{IlHx|@+e9tTC{Es8lss|4`h_O>0vFxq#^(W)>QJK{`IC0?n4gcp#RDeT7`}zk^&25O1iB zjZ-9<@Y&7J*<7nk`{C>!>&FNezO>Aw%&25P!Om z4hYX`FtoDcC>zn}mE6QBtpS8ozKW>p)|gw@<-J4>U>gTWj_DHo_jkQRmI?B#fd-Q+ zgeMMxTM=!Um7$9=TCpRzv7eaVho&0fC>|hfrWElWGyPJBe1%$cRgC;jsCnyJ;5~~` zd>>4ouY$F|!~au+tNuOSJI|Ctlb0ZA?oVPMS100SQN(2&RsBJ%tx}`q7(yUUu$7;~ zKT}hS$$9KG5JEBGR#v&yq9Siu85HKDB=>Aove#_6G($hP`E$d77;#$!yse*RI@enH zIv+{Nqdc)q90YdVglBRv=1JE=DeKWBv#Ml-w%YqyLj%Wd-K!PXvR;*LJ$^h{$X>*@ zuL%jwJkVHtq0otk)*A_6APZzGNgck`r?l(!z3M-Zs);sb$YZoZz@0{TTo((ex|W!N zD5vPRNC27q;SbWXleDWQn@$S#do`XywdZAHOlck+CE?V^q<2IxjX~!eT79PVLJ)55 zPXiF=Y^1+WQCeoC0C>FIRB_LM~N_hMGv1Ho2I+24l8H=gd=Jt>^`x(Dj& zQj;(=jdR)yn}AmvT~lg}dr;j^Ox7e{4zjRo8%AZDXEo>un+G$W)rvkm&L#&6ZX9G! z5#4Y->0n5aZ3pZlI_>VMsCg$-OEhy0Kh)N&6=GJ#m(QRG%zdQvtEBzH6LwGG3VAlcboqKPZ zxul^KhI|&z-*TXj=Us@6so<;LCgO|^SyEGsNj>_IHM+qYcz=)s#8AnTl1F+ZZ7M)F zQVn{eUxtSd35DLYh)9$qygZ1(~cp|oFs$S!D z~`;_z)Z5GzF2(*^t4o5CT$0`%VMApqY_FwNZpElHBzrBfp3 z$;PK)i}>{Ns^?_7l`JSuZP-4la5&w4mwERrXpZA>)1xfJ)(ghDeQ_R8STW8R@g|^p z2n&88ILlcE4d4?`io{eO1b!q|LrIJNp9Fub^^?fxd6YW;62nH?_&r6SBw~im(VMK`t}4->>Dnjlpu>mkrmc8?l`_@~+XCd7T#Ba5?mn>qOP%(c zJy`0RJ(6hS6r)u$qgZ>h`{Lz$)NeDaSE~%w3$1)zA$d|6mwc5^P*Ml9o9-O0TXtaD zc6-aq)O5wx@ZT*|+leEw0TB>!#m1LXl{xE5To0`>NxM;ynstxB6c=XVy+XaQP5q`x z9_r8I&&?_6Fz=D~C$F(_@TK221gm^FHOe-PMsc5t%+wX@XU$*ShEVE`WG52`8NBO) zulEPXpB>!28FEir?ljk$DS~yr+j^&hE9M=th?+M9OUYL$MW9{y;*t`f)biPD)MWXd zb=m*B|1!-N#bAqLLCfNCgVsIMm85-NnQo0>#p`RR?}m7ErNTC1Z24ho7T!c|XYoRwkweRyNLZBj%OT zWfx1>XMOyFPo84TN~*ph+%)<@v9!%fb{Vz!N3@II?tH<<1;xQeI6U>VYESeir zcm0+YQs`@60lF>Ft05DFYTGS--z|TlT^}s7@zbL~i55b?SM2bjzDlScQ`8rClRA=; zl*)`0`|v|T;293K5Lmva+~5aZ`R^~4YtuB_TpMk#!0rUg zirpKXD}KCoS?wD|d96V32zP3>uJi;Tc;8CeC@}Rk@LELk9xr|y!Y@R-(@nc*SKDwd zb&Xx_ERT0*yJ>HtouF%_`JsIcdqTbGA9Qf|kJyxUr+yh{#Vj&_D%g=>nMn4;2|4J1 z=XKnkUwbjw90XW~fJ$Hq6A4B+=pgG;JuN}Q0W^5c^97m`+Uu+F9=b0vru(nmkueK8 z05spUc(T5*`9tu~I^2Mrbif-hNgW2W)`*1o^g@Tn^8~{bopJMn`TE|kX8*I*{la;F zdg~6dFeSOqp{Nopy4J&+UR?;Pec9ksJ)9-Yk3(JuS(b=F;WgTIOV$0)-*36B-?_IG{jHOUuY8ze=H=2RvU;RE$C&y+pi#=9}Ql5d@l)}k@_SNiWc zHlVQT%`8M=Bqrbt$K6`iNAMZ{XYjeN@I`G1TP9JO{tP^B}dV4TM%Hmn2DZsFP zyU3L8=B(MtW=ivg|HPE;f&ZB)Wl8U{dNxI(>uw9jeJkhu)X65y|^{iR-a9{4`#f${ah|do0(QXDefno~dUn@q_$qHgAzhT1@m*FuAlCgprBBliXnXXXg2Jt*$^jPv@`7G!5#X$1f5G&G=K>BK6 zPeuMRY8H8avokY zV(esOuf*LVbtY~Muhur1Kx>lNX9n34aeRw@%ah60!pq3J?-)|J#^#l(H}pfti&OJu zra4)6puk~$9i0Pu$=+ievS7@pP#)wXBLT^2zQy# z^Lx33SgFx7_@Rit&)jb?J3kDsd?vWHTaNa?>U3k%dwV-3U3rb=MBee!N(%R*hV071 zro5)JpRI8%Ov}|KIH7#8#Uu67K3r1X?CkTU=c2vM3wh=K9wG0k<3A$geddI)dHC6; zRN&4g0E;MZv0ICH_|N74Z{LkH2A#df!f!yx!Z_6Smos*MUy1Q4MtpHaS;!R5e9ROg zK|R_L3zUu7r>=f>^(~^3>>CCGN+wL4Q(i$8=6xW^wvF2R0(>YQJWeGTTX-1F-ipv~ zb}c|uupNiZW(I(4L)OYa%kx0lf{L%(M-lHOkV*aaG<@HuethEZAqc=Y^q&G7k*L=5Arkr{1VE%w&9<7U{{QZF_9p?;esYN z78IViAIEBhmGVW2&9Ihh_+{HAH`=T>sK~J?-`DbHR9KC!wn=%4tH$?8?i2^V3?B(Y zwPo^~WE)J5DO^u(z!*_`fB(#PevdZn0W+Ks{;q2o;>=&7y@q%O`{XJE0g6n?GC_L0 zyu%LZ7J=2}hD3-PIm@}I5u?h4J=*0|6p&TuDBNj)p>ED%fd^*|872=q_1hTjN}H51 zr)6w}0EO1?(j9-?fT)5(mmzoDzQVXV3#sJenZHfZmUP|d7(vE~*|ZT8q4uUDqUM4Y zeN>d*lgf2awH>CCB8t4-yysC_zcOC8kW(~q9{}79^3h=0?!!=GlY9|xv+?SG@JbA*`WlvuAHBskFjo#Ad z-uGB-fdT*4ql4a|B?eMH1@V`b#RQHw(*g;3m?x` zRcn*N5NXd>vU#+d``z2GYj5V!Jk}MmEy7oLi!K~>wJ}M8xn3#enqZ!Dyb81;7S$%j zDsndSjn39BTCOU8Saj4kIctghbp!8;b=>NFysnMuY5fT{rqvqA!n$>Ki0U37FL^aA zUOj!2R`t@=?$>w^Z>?xc%uh&|ktlsBGQQtklgrqozRlFuC!-`T$K0*U(?3$Wi9Xfx*k#WcQ7_nYZuuMlAV(J=3s)J6_TpA;=W3erHM5Rr|n13Pmfx zt(s2e9A$>5qPuz3|R{sDdEwF)78$3MRX6oXNh5pihgx?hqoL+2GG}loCeH%F~ao|xelD0bjsWp04RQf4t z=cvTh!m>B(<(3>fQr$Cr$ljs7`Qd)6r|Y!SvnQ8}30AMra%gK>_FGXCM`@sfwvq6S zg3(7Qr=;^f@LgB0jFl|BCghx3L@zY+m&RX=OF33iv&Jcb=-aMYX!ocdR3-Vh7#G^j9bx z1^%{!!Su!f5;`esLEibVw_UUrH=$Y8B2m&Q_72Gqi|v$y5!0m$5(FYd^;x!7n3G5A z#p7D`pWOMn!R!{Nz?R05M0=;2AlawrGGi5xQU+O|z_|TZC|U!f%l!v(xeD;4UG)-Q zb^Pf`B#pOaEv)PX-}4xLEk)Oqy9RyCl!3W*FW*K!0}qV-#NoBY^kO;tFkRT^VvR2s zMi>)9r)uc;5`0$5r6#c-*W^5?8AR}h~u9YNYH=QVqq8mGY|jA<^du(n_~!n S$Xg2m|18(pt}Qns9{hidY8kZv literal 0 HcmV?d00001 diff --git a/styles/terminal/terminal.rgs b/styles/terminal/terminal.rgs new file mode 100644 index 0000000..fed8709 --- /dev/null +++ b/styles/terminal/terminal.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 16 0 Mecha.ttf +p 00 00 0x1c8d00ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0x161313ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0x38f620ff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0xc3fbc6ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0x43bf2eff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0xdcfadcff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0x1f5b19ff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0x43ff28ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0x1e6f15ff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x223b22ff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0x182c18ff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x244125ff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x00000010 TEXT_SIZE +p 00 57 0x00000000 TEXT_SPACING +p 00 18 0xe6fce3ff DEFAULT_LINE_COLOR +p 00 19 0x0c1505ff DEFAULT_BACKGROUND_COLOR

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 L+xi-NzqtPcx4&iQ literal 0 HcmV?d00001 diff --git a/styles/cyber/Kyrou 7 Wide.ttf b/styles/cyber/Kyrou 7 Wide.ttf new file mode 100644 index 0000000000000000000000000000000000000000..4c86f19ab64f11febad6cfa1e2dbc70e9c162e0a GIT binary patch literal 85240 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 literal 0 HcmV?d00001 diff --git a/styles/cyber/README.md b/styles/cyber/README.md new file mode 100644 index 0000000..10de60b --- /dev/null +++ b/styles/cyber/README.md @@ -0,0 +1,16 @@ +style: cyber +------------- +Future is now! Neons and shadows, city never sleeps! Robots waiting in the corners and expensive vending machines! You got the style! + +![cyber style table](style_table.png) + +screenshot +----------- + +![cyber style screen](screenshot.png) + +about font +----------- +"Grixel Kyrou 7 Wide" font by [Nikos Giannakopoulos](http://www.grixel.gr/). + +100% free font, downloaded from dafont.com: [grixel-kyrou-7-wide](https://www.dafont.com/grixel-kyrou-7-wide.font) diff --git a/styles/cyber/cyber.rgs b/styles/cyber/cyber.rgs new file mode 100644 index 0000000..e72b1b8 --- /dev/null +++ b/styles/cyber/cyber.rgs @@ -0,0 +1,24 @@ +# +# rgs style text file (v3.1) - raygui style file generated using rGuiStyler +# +# Style properties: +# f +# p +# +f 14 0 Kyrou 7 Wide.ttf +p 00 00 0x2f7486ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0x024658ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0x51bfd3ff DEFAULT_TEXT_COLOR_NORMAL +p 00 00 0x82cde0ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 00 0x3299b4ff DEFAULT_BASE_COLOR_FOCUSED +p 00 00 0xb6e1eaff DEFAULT_TEXT_COLOR_FOCUSED +p 00 00 0xeb7630ff DEFAULT_BORDER_COLOR_PRESSED +p 00 00 0xffbc51ff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0xd86f36ff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0x134b5aff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0x02313dff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0x17505fff DEFAULT_TEXT_COLOR_DISABLED +p 00 16 0x0000000e DEFAULT_TEXT_SIZE +p 00 25 0x00000000 DEFAULT_TEXT_SPACING +p 00 18 0x81c0d0ff DEFAULT_LINE_COLOR +p 00 19 0x00222bff DEFAULT_BACKGROUND_COLOR diff --git a/styles/cyber/font_readme.txt b/styles/cyber/font_readme.txt new file mode 100644 index 0000000..45def0a --- /dev/null +++ b/styles/cyber/font_readme.txt @@ -0,0 +1,36 @@ +Thank you for downloading the free Grixel fonts. You can use them in your personal and commercial projects too. They include Western European, Central European, Turkish and Greek characters. They are Unicode TrueType fonts and are optimized to work in both Windows XP and Mac OS X platforms using Adobe Photoshop CS2 and Macromedia Flash 8. + + +Grixel fonts are under Creative Commons Attribution-NoDerivs 2.5 License which can be found here: + +http://creativecommons.org/licenses/by-nd/2.5/ + +=============================================================== +Attribution-NoDerivs 2.5 + +You are free: + + * to copy, distribute, display, and perform the work + * to make commercial use of the work + +Under the following conditions: + +by +Attribution. You must attribute the work in the manner specified by the author or licensor. + +nd +No Derivative Works. You may not alter, transform, or build upon this work. + + * For any reuse or distribution, you must make clear to others the license terms of this work. + * Any of these conditions can be waived if you get permission from the copyright holder. + +Your fair use and other rights are in no way affected by the above. +=============================================================== + + +In no event shall Nikos Giannakopoulos be held liable to you for any consequential or incidental damages, including any lost revenue, profits, goodwill or savings, or for any claim by any third party caused by using these fonts. + +Please read the UsageGuides.pdf before you use them. + + +Grixel - Greek pixel fonts | Nikos Giannakopoulos | www.grixel.gr \ No newline at end of file diff --git a/styles/cyber/screenshot.png b/styles/cyber/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..5f0b4b7c6b5dd6805d6be96afec52ade74ccf7cf GIT binary patch literal 55540 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 literal 0 HcmV?d00001 diff --git a/styles/cyber/style_table.png b/styles/cyber/style_table.png new file mode 100644 index 0000000000000000000000000000000000000000..b16d320afdb2708a634fc25cd9a8819538cf48ed GIT binary patch literal 25413 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%0AY6<50dIpf( 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 orS~TNV-Nq>!@t` +# p +# +p 00 00 0x838383ff DEFAULT_BORDER_COLOR_NORMAL +p 00 01 0xc9c9c9ff DEFAULT_BASE_COLOR_NORMAL +p 00 02 0x686868ff DEFAULT_TEXT_COLOR_NORMAL +p 00 03 0x5bb2d9ff DEFAULT_BORDER_COLOR_FOCUSED +p 00 04 0xc9effeff DEFAULT_BASE_COLOR_FOCUSED +p 00 05 0x6c9bbcff DEFAULT_TEXT_COLOR_FOCUSED +p 00 06 0x0492c7ff DEFAULT_BORDER_COLOR_PRESSED +p 00 07 0x97e8ffff DEFAULT_BASE_COLOR_PRESSED +p 00 08 0x368bafff DEFAULT_TEXT_COLOR_PRESSED +p 00 09 0xb5c1c2ff DEFAULT_BORDER_COLOR_DISABLED +p 00 10 0xe6e9e9ff DEFAULT_BASE_COLOR_DISABLED +p 00 11 0xaeb7b8ff DEFAULT_TEXT_COLOR_DISABLED +p 00 12 0x1 DEFAULT_BORDER_WIDTH +p 00 13 0x0 DEFAULT_TEXT_PADDING +p 00 14 0x1 DEFAULT_TEXT_ALIGNMENT +p 00 15 0x0 DEFAULT_RESERVED +p 00 16 0xa DEFAULT_TEXT_SIZE +p 00 17 0x1 DEFAULT_TEXT_SPACING +p 00 18 0x90abb5ff DEFAULT_LINE_COLOR +p 00 19 0xf5f5f5ff DEFAULT_BACKGROUND_COLOR +p 01 14 0x0 LABEL_TEXT_ALIGNMENT +p 02 12 0x2 BUTTON_BORDER_WIDTH +p 03 16 0x2 TOGGLE_GROUP_PADDING +p 04 16 0xf SLIDER_SLIDER_WIDTH +p 04 13 0x5 SLIDER_TEXT_PADDING +p 05 16 0x1 PROGRESSBAR_PROGRESS_PADDING +p 06 13 0x5 CHECKBOX_TEXT_PADDING +p 06 14 0x2 CHECKBOX_TEXT_ALIGNMENT +p 06 16 0x1 CHECKBOX_CHECK_PADDING +p 07 16 0x1e COMBOBOX_COMBO_BUTTON_WIDTH +p 07 17 0x2 COMBOBOX_COMBO_BUTTON_PADDING +p 08 16 0x10 DROPDOWNBOX_ARROW_PADDING +p 08 17 0x2 DROPDOWNBOX_DROPDOWN_ITEMS_PADDING +p 09 13 0x5 TEXTBOX_TEXT_PADDING +p 09 14 0x0 TEXTBOX_TEXT_ALIGNMENT +p 09 16 0x5 TEXTBOX_TEXT_LINES_PADDING +p 09 17 0xf0fffeff TEXTBOX_COLOR_SELECTED_FG +p 09 18 0x839affe0 TEXTBOX_COLOR_SELECTED_BG +p 10 13 0x4 VALUEBOX_TEXT_PADDING +p 10 14 0x0 VALUEBOX_TEXT_ALIGNMENT +p 11 13 0x4 SPINNER_TEXT_PADDING +p 11 14 0x0 SPINNER_TEXT_ALIGNMENT +p 11 16 0x14 SPINNER_SPIN_BUTTON_WIDTH +p 11 17 0x2 SPINNER_SPIN_BUTTON_PADDING +p 12 16 0x1e LISTVIEW_LIST_ITEMS_HEIGHT +p 12 17 0x2 LISTVIEW_LIST_ITEMS_PADDING +p 12 18 0xa LISTVIEW_SCROLLBAR_WIDTH +p 12 19 0x2 LISTVIEW_SCROLLBAR_SIDE +p 13 16 0x6 COLORPICKER_COLOR_SELECTOR_SIZE +p 13 17 0x14 COLORPICKER_HUEBAR_WIDTH +p 13 18 0xa COLORPICKER_HUEBAR_PADDING +p 13 19 0x6 COLORPICKER_HUEBAR_SELECTOR_HEIGHT +p 13 20 0x2 COLORPICKER_HUEBAR_SELECTOR_OVERFLOW +p 14 12 0x0 SCROLLBAR_BORDER_WIDTH +p 14 16 0x6 SCROLLBAR_ARROWS_SIZE +p 14 17 0x0 SCROLLBAR_ARROWS_VISIBLE +p 14 18 0x0 SCROLLBAR_SCROLL_SLIDER_PADDING +p 14 19 0x10 SCROLLBAR_SCROLL_SLIDER_SIZE +p 14 20 0x0 SCROLLBAR_SCROLL_PADDING +p 14 21 0xa SCROLLBAR_SCROLL_SPEED +p 15 13 0xa STATUSBAR_TEXT_PADDING +p 15 14 0x0 STATUSBAR_TEXT_ALIGNMENT diff --git a/styles/default/screenshot.png b/styles/default/screenshot.png new file mode 100644 index 0000000000000000000000000000000000000000..c3b750a65de62b361cb5f5a8958c3ebc99ccc663 GIT binary patch literal 55326 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