UnrealXR/raylib-python-cffi
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

generate h files on linux and then use them on windows

Browse source
This commit is contained in:
richard 2021-10-16 20:46:52 +01:00
parent 10545a2f37
commit ef2d56308a
16 changed files with 2533 additions and 384 deletions
Download patch file Download diff file Expand all files Collapse all files

1
create_stub_static.py
View file

@ -66,6 +66,7 @@ for name, attr in getmembers(rl):
" ", "")+"_"+str(i) " ", "")+"_"+str(i)
if 'params' in json_object: if 'params' in json_object:
p = json_object['params'] p = json_object['params']
#print("param_name: ", param_name, "i", i, "params: ",p,file=sys.stderr)
param_name = list(p)[i] param_name = list(p)[i]
param_type = ctype_to_python_type(arg.cname) param_type = ctype_to_python_type(arg.cname)
sig += f"{param_name}: {param_type}," sig += f"{param_name}: {param_type},"

93
raylib/build.py
View file

@ -45,11 +45,15 @@ def pre_process_header(filename):
print("Pre-processing " + filename) print("Pre-processing " + filename)
file = open(filename, "r") file = open(filename, "r")
filetext = "".join([line for line in file if '#include' not in line]) filetext = "".join([line for line in file if '#include' not in line])
command = ['gcc', '-CC', '-P', '-undef', '-nostdinc', '-DRLAPI=', '-DPHYSACDEF=', '-DRAYGUIDEF=', command = ['gcc', '-CC', '-P', '-undef', '-nostdinc', '-DRL_MATRIX_TYPE',
#'-DRL_QUATERNION_TYPE','-DRL_VECTOR4_TYPE','-DRL_VECTOR3_TYPE','-DRL_VECTOR2_TYPE'
'-DRLAPI=', '-DPHYSACDEF=', '-DRAYGUIDEF=',
'-dDI', '-E', '-'] '-dDI', '-E', '-']
filetext2 = subprocess.run(command, text=True, input=filetext, stdout=subprocess.PIPE).stdout filetext2 = subprocess.run(command, text=True, input=filetext, stdout=subprocess.PIPE).stdout
filetext3 = filetext2.replace("va_list", "void *") filetext3 = filetext2.replace("va_list", "void *")
filetext4 = "\n".join([line for line in filetext3.splitlines() if not line.startswith("#")]) filetext4 = "\n".join([line for line in filetext3.splitlines() if not line.startswith("#")])
file = open("raylib/"+os.path.basename(filename)+".modified", "w")
file.write(filetext4)
# print(r) # print(r)
return filetext4 return filetext4
@ -65,31 +69,31 @@ def check_header_exists(file):
return True return True
def mangle(file): # def mangle(file):
result = "" # result = ""
skip = False # skip = False
for line in open(file): # for line in open(file):
line = line.strip().replace("va_list", "void *") + "\n" # line = line.strip().replace("va_list", "void *") + "\n"
if skip: # if skip:
if line.startswith("#endif"): # if line.startswith("#endif"):
skip = False # skip = False
continue # continue
if line.startswith("#if defined(__cplusplus)"): # if line.startswith("#if defined(__cplusplus)"):
skip = True # skip = True
continue # continue
if line.startswith("#endif // RAYGUI_H"): # if line.startswith("#endif // RAYGUI_H"):
break # break
if line.startswith("#"): # if line.startswith("#"):
continue # continue
if line.startswith("RLAPI"): # if line.startswith("RLAPI"):
line = line.replace('RLAPI ', '') # line = line.replace('RLAPI ', '')
if line.startswith("RAYGUIDEF"): # if line.startswith("RAYGUIDEF"):
line = line.replace('RAYGUIDEF ', '') # line = line.replace('RAYGUIDEF ', '')
if line.startswith("PHYSACDEF"): # if line.startswith("PHYSACDEF"):
line = line.replace('PHYSACDEF ', '') # line = line.replace('PHYSACDEF ', '')
result += line # result += line
# print(line) # # print(line)
return result # return result
def build_unix(): def build_unix():
@ -97,12 +101,21 @@ def build_unix():
raise Exception("ERROR: raylib not found by pkg-config. Please install pkg-config and Raylib.") raise Exception("ERROR: raylib not found by pkg-config. Please install pkg-config and Raylib.")
raylib_h = get_the_include_path() + "/raylib.h" raylib_h = get_the_include_path() + "/raylib.h"
rlgl_h = get_the_include_path() + "/rlgl.h"
#raymath_h = get_the_include_path() + "/raymath.h"
if not os.path.isfile(raylib_h): if not os.path.isfile(raylib_h):
raise Exception("ERROR: " + raylib_h + " not found. Please install Raylib.") raise Exception("ERROR: " + raylib_h + " not found. Please install Raylib.")
if not os.path.isfile(rlgl_h):
raise Exception("ERROR: " + raylib_h + " not found. Please install Raylib.")
#if not os.path.isfile(raymath_h):
# raise Exception("ERROR: " + raylib_h + " not found. Please install Raylib.")
ffi_includes = """ ffi_includes = """
#include "raylib.h" #include "raylib.h"
#include "rlgl.h"
""" """
raygui_h = get_the_include_path() + "/raygui.h" raygui_h = get_the_include_path() + "/raygui.h"
@ -121,6 +134,10 @@ def build_unix():
""" """
ffibuilder.cdef(pre_process_header(raylib_h)) ffibuilder.cdef(pre_process_header(raylib_h))
ffibuilder.cdef(pre_process_header(rlgl_h))
#ffibuilder.cdef(pre_process_header(raymath_h))
#print("******************************\n\n\n")
#print(pre_process_header(rlgl_h))
if os.path.isfile(raygui_h): if os.path.isfile(raygui_h):
ffibuilder.cdef(pre_process_header(raygui_h)) ffibuilder.cdef(pre_process_header(raygui_h))
if os.path.isfile(physac_h): if os.path.isfile(physac_h):
@ -132,30 +149,30 @@ def build_unix():
'-framework', 'IOKit', '-framework', 'CoreFoundation', '-framework', '-framework', 'IOKit', '-framework', 'CoreFoundation', '-framework',
'CoreVideo'] 'CoreVideo']
libraries = [] libraries = []
elif platform.system() == "Linux": else: #platform.system() == "Linux":
if "x86" in platform.machine(): if "arm" in platform.machine():
print("BUILDING FOR LINUX")
extra_link_args = [get_the_lib_path() + '/libraylib.a', '-lm', '-lpthread', '-lGLU', '-lGL',
'-lrt', '-lm', '-ldl', '-lX11', '-lpthread']
libraries = ['GL', 'm', 'pthread', 'dl', 'rt', 'X11']
elif "arm" in platform.machine():
print("BUILDING FOR RASPBERRY PI") print("BUILDING FOR RASPBERRY PI")
extra_link_args = [get_the_lib_path() + '/libraylib.a', extra_link_args = [get_the_lib_path() + '/libraylib.a',
'/opt/vc/lib/libEGL_static.a', '/opt/vc/lib/libGLESv2_static.a', '/opt/vc/lib/libEGL_static.a', '/opt/vc/lib/libGLESv2_static.a',
'-L/opt/vc/lib', '-lvcos', '-lbcm_host', '-lbrcmEGL', '-lbrcmGLESv2', '-L/opt/vc/lib', '-lvcos', '-lbcm_host', '-lbrcmEGL', '-lbrcmGLESv2',
'-lm', '-lpthread', '-lrt'] '-lm', '-lpthread', '-lrt']
libraries = [] libraries = []
else: #"x86" in platform.machine():
print("BUILDING FOR LINUX")
extra_link_args = [get_the_lib_path() + '/libraylib.a', '-lm', '-lpthread', '-lGLU', '-lGL',
'-lrt', '-lm', '-ldl', '-lX11', '-lpthread']
libraries = ['GL', 'm', 'pthread', 'dl', 'rt', 'X11']
ffibuilder.set_source("raylib._raylib_cffi", ffi_includes, extra_link_args=extra_link_args, ffibuilder.set_source("raylib._raylib_cffi", ffi_includes, extra_link_args=extra_link_args,
libraries=libraries, libraries=libraries)
include_dirs=['raylib'])
def build_windows(): def build_windows():
print("BUILDING FOR WINDOWS") print("BUILDING FOR WINDOWS")
ffibuilder.cdef(mangle("raylib/raylib.h")) ffibuilder.cdef(open("raylib/raylib.h.modified").read())
ffibuilder.cdef(open("raylib/raygui_modified.h").read().replace('RAYGUIDEF ', '')) ffibuilder.cdef(open("raylib/rlgl.h.modified").read())
ffibuilder.cdef(open("raylib/physac_modified.h").read().replace('PHYSACDEF ', '')) ffibuilder.cdef(open("raylib/raygui.h.modified").read())
ffibuilder.cdef(open("raylib/physac.h.modified").read())
ffibuilder.set_source("raylib._raylib_cffi", """ ffibuilder.set_source("raylib._raylib_cffi", """
#include "raylib.h" #include "raylib.h"
#define RAYGUI_IMPLEMENTATION #define RAYGUI_IMPLEMENTATION

2
raylib/build_multi.sh
View file

@ -20,5 +20,5 @@ function build() {
build 3.9.5 build 3.9.5
build 3.8.10 build 3.8.10
build 3.7.10 build 3.7.10
build 3.6.13

2
raylib/build_multi_linux.sh
View file

@ -20,5 +20,5 @@ function build() {
build 3.9.5 build 3.9.5
build 3.8.10 build 3.8.10
build 3.7.10 build 3.7.10
build 3.6.13

2
raylib/build_multi_rpi_nox.sh
View file

@ -20,5 +20,5 @@ function build() {
build 3.9.5 build 3.9.5
build 3.8.10 build 3.8.10
build 3.7.10 build 3.7.10
build 3.6.13

170
raylib/physac.h.modified Normal file
View file

@ -0,0 +1,170 @@
/**********************************************************************************************
*
* Physac v1.1 - 2D Physics library for videogames
*
* DESCRIPTION:
*
* Physac is a small 2D physics engine written in pure C. The engine uses a fixed time-step thread loop
* to simluate physics. A physics step contains the following phases: get collision information,
* apply dynamics, collision solving and position correction. It uses a very simple struct for physic
* bodies with a position vector to be used in any 3D rendering API.
*
* CONFIGURATION:
*
* #define PHYSAC_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 PHYSAC_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 PHYSAC_DEBUG
* Show debug traces log messages about physic bodies creation/destruction, physic system errors,
* some calculations results and NULL reference exceptions
*
* #define PHYSAC_DEFINE_VECTOR2_TYPE
* Forces library to define struct Vector2 data type (float x; float y)
*
* #define PHYSAC_AVOID_TIMMING_SYSTEM
* Disables internal timming system, used by UpdatePhysics() to launch timmed physic steps,
* it allows just running UpdatePhysics() automatically on a separate thread at a desired time step.
* In case physics steps update needs to be controlled by user with a custom timming mechanism,
* just define this flag and the internal timming mechanism will be avoided, in that case,
* timming libraries are neither required by the module.
*
* #define PHYSAC_MALLOC()
* #define PHYSAC_CALLOC()
* #define PHYSAC_FREE()
* You can define your own malloc/free implementation replacing stdlib.h malloc()/free() functions.
* Otherwise it will include stdlib.h and use the C standard library malloc()/free() function.
*
* COMPILATION:
*
* Use the following code to compile with GCC:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s -static -lraylib -lopengl32 -lgdi32 -lwinmm -std=c99
*
* VERSIONS HISTORY:
* 1.1 (20-Jan-2021) @raysan5: Library general revision
* Removed threading system (up to the user)
* Support MSVC C++ compilation using CLITERAL()
* Review DEBUG mechanism for TRACELOG() and all TRACELOG() messages
* Review internal variables/functions naming for consistency
* Allow option to avoid internal timming system, to allow app manage the steps
* 1.0 (12-Jun-2017) First release of the library
*
*
* LICENSE: zlib/libpng
*
* Copyright (c) 2016-2021 Victor Fisac (@victorfisac) and 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.
*
**********************************************************************************************/
// Allow custom memory allocators
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
//----------------------------------------------------------------------------------
// Data Types Structure Definition
//----------------------------------------------------------------------------------
typedef enum PhysicsShapeType { PHYSICS_CIRCLE = 0, PHYSICS_POLYGON } PhysicsShapeType;
// Previously defined to be used in PhysicsShape struct as circular dependencies
typedef struct PhysicsBodyData *PhysicsBody;
// Matrix2x2 type (used for polygon shape rotation matrix)
typedef struct Matrix2x2 {
float m00;
float m01;
float m10;
float m11;
} Matrix2x2;
typedef struct PhysicsVertexData {
unsigned int vertexCount; // Vertex count (positions and normals)
Vector2 positions[24 /* Maximum number of vertex for polygons shapes*/]; // Vertex positions vectors
Vector2 normals[24 /* Maximum number of vertex for polygons shapes*/]; // Vertex normals vectors
} PhysicsVertexData;
typedef struct PhysicsShape {
PhysicsShapeType type; // Shape type (circle or polygon)
PhysicsBody body; // Shape physics body data pointer
PhysicsVertexData vertexData; // Shape vertices data (used for polygon shapes)
float radius; // Shape radius (used for circle shapes)
Matrix2x2 transform; // Vertices transform matrix 2x2
} PhysicsShape;
typedef struct PhysicsBodyData {
unsigned int id; // Unique identifier
bool enabled; // Enabled dynamics state (collisions are calculated anyway)
Vector2 position; // Physics body shape pivot
Vector2 velocity; // Current linear velocity applied to position
Vector2 force; // Current linear force (reset to 0 every step)
float angularVelocity; // Current angular velocity applied to orient
float torque; // Current angular force (reset to 0 every step)
float orient; // Rotation in radians
float inertia; // Moment of inertia
float inverseInertia; // Inverse value of inertia
float mass; // Physics body mass
float inverseMass; // Inverse value of mass
float staticFriction; // Friction when the body has not movement (0 to 1)
float dynamicFriction; // Friction when the body has movement (0 to 1)
float restitution; // Restitution coefficient of the body (0 to 1)
bool useGravity; // Apply gravity force to dynamics
bool isGrounded; // Physics grounded on other body state
bool freezeOrient; // Physics rotation constraint
PhysicsShape shape; // Physics body shape information (type, radius, vertices, transform)
} PhysicsBodyData;
typedef struct PhysicsManifoldData {
unsigned int id; // Unique identifier
PhysicsBody bodyA; // Manifold first physics body reference
PhysicsBody bodyB; // Manifold second physics body reference
float penetration; // Depth of penetration from collision
Vector2 normal; // Normal direction vector from 'a' to 'b'
Vector2 contacts[2]; // Points of contact during collision
unsigned int contactsCount; // Current collision number of contacts
float restitution; // Mixed restitution during collision
float dynamicFriction; // Mixed dynamic friction during collision
float staticFriction; // Mixed static friction during collision
} PhysicsManifoldData, *PhysicsManifold;
//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
// Physics system management
extern /* Functions visible from other files*/ void InitPhysics(void); // Initializes physics system
extern /* Functions visible from other files*/ void UpdatePhysics(void); // Update physics system
extern /* Functions visible from other files*/ void ResetPhysics(void); // Reset physics system (global variables)
extern /* Functions visible from other files*/ void ClosePhysics(void); // Close physics system and unload used memory
extern /* Functions visible from other files*/ void SetPhysicsTimeStep(double delta); // Sets physics fixed time step in milliseconds. 1.666666 by default
extern /* Functions visible from other files*/ void SetPhysicsGravity(float x, float y); // Sets physics global gravity force
// Physic body creation/destroy
extern /* Functions visible from other files*/ PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density); // Creates a new circle physics body with generic parameters
extern /* Functions visible from other files*/ PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density); // Creates a new rectangle physics body with generic parameters
extern /* Functions visible from other files*/ PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density); // Creates a new polygon physics body with generic parameters
extern /* Functions visible from other files*/ void DestroyPhysicsBody(PhysicsBody body); // Destroy a physics body
// Physic body forces
extern /* Functions visible from other files*/ void PhysicsAddForce(PhysicsBody body, Vector2 force); // Adds a force to a physics body
extern /* Functions visible from other files*/ void PhysicsAddTorque(PhysicsBody body, float amount); // Adds an angular force to a physics body
extern /* Functions visible from other files*/ void PhysicsShatter(PhysicsBody body, Vector2 position, float force); // Shatters a polygon shape physics body to little physics bodies with explosion force
extern /* Functions visible from other files*/ void SetPhysicsBodyRotation(PhysicsBody body, float radians); // Sets physics body shape transform based on radians parameter
// Query physics info
extern /* Functions visible from other files*/ PhysicsBody GetPhysicsBody(int index); // Returns a physics body of the bodies pool at a specific index
extern /* Functions visible from other files*/ int GetPhysicsBodiesCount(void); // Returns the current amount of created physics bodies
extern /* Functions visible from other files*/ int GetPhysicsShapeType(int index); // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
extern /* Functions visible from other files*/ int GetPhysicsShapeVerticesCount(int index); // Returns the amount of vertices of a physics body shape
extern /* Functions visible from other files*/ Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex); // Returns transformed position of a body shape (body position + vertex transformed position)
/***********************************************************************************
*
* PHYSAC IMPLEMENTATION
*
************************************************************************************/

98
raylib/physac_modified.h
View file

@ -1,98 +0,0 @@
#define PHYSAC_MAX_BODIES 64 // Maximum number of physic bodies supported
#define PHYSAC_MAX_MANIFOLDS 4096 // Maximum number of physic bodies interactions (64x64)
#define PHYSAC_MAX_VERTICES 24 // Maximum number of vertex for polygons shapes
#define PHYSAC_DEFAULT_CIRCLE_VERTICES 24 // Default number of vertices for circle shapes
typedef enum PhysicsShapeType { PHYSICS_CIRCLE = 0, PHYSICS_POLYGON } PhysicsShapeType;
// Previously defined to be used in PhysicsShape struct as circular dependencies
typedef struct PhysicsBodyData *PhysicsBody;
// Matrix2x2 type (used for polygon shape rotation matrix)
typedef struct Matrix2x2 {
float m00;
float m01;
float m10;
float m11;
} Matrix2x2;
typedef struct PhysicsVertexData {
unsigned int vertexCount; // Vertex count (positions and normals)
Vector2 positions[PHYSAC_MAX_VERTICES]; // Vertex positions vectors
Vector2 normals[PHYSAC_MAX_VERTICES]; // Vertex normals vectors
} PhysicsVertexData;
typedef struct PhysicsShape {
PhysicsShapeType type; // Shape type (circle or polygon)
PhysicsBody body; // Shape physics body data pointer
PhysicsVertexData vertexData; // Shape vertices data (used for polygon shapes)
float radius; // Shape radius (used for circle shapes)
Matrix2x2 transform; // Vertices transform matrix 2x2
} PhysicsShape;
typedef struct PhysicsBodyData {
unsigned int id; // Unique identifier
bool enabled; // Enabled dynamics state (collisions are calculated anyway)
Vector2 position; // Physics body shape pivot
Vector2 velocity; // Current linear velocity applied to position
Vector2 force; // Current linear force (reset to 0 every step)
float angularVelocity; // Current angular velocity applied to orient
float torque; // Current angular force (reset to 0 every step)
float orient; // Rotation in radians
float inertia; // Moment of inertia
float inverseInertia; // Inverse value of inertia
float mass; // Physics body mass
float inverseMass; // Inverse value of mass
float staticFriction; // Friction when the body has not movement (0 to 1)
float dynamicFriction; // Friction when the body has movement (0 to 1)
float restitution; // Restitution coefficient of the body (0 to 1)
bool useGravity; // Apply gravity force to dynamics
bool isGrounded; // Physics grounded on other body state
bool freezeOrient; // Physics rotation constraint
PhysicsShape shape; // Physics body shape information (type, radius, vertices, transform)
} PhysicsBodyData;
typedef struct PhysicsManifoldData {
unsigned int id; // Unique identifier
PhysicsBody bodyA; // Manifold first physics body reference
PhysicsBody bodyB; // Manifold second physics body reference
float penetration; // Depth of penetration from collision
Vector2 normal; // Normal direction vector from 'a' to 'b'
Vector2 contacts[2]; // Points of contact during collision
unsigned int contactsCount; // Current collision number of contacts
float restitution; // Mixed restitution during collision
float dynamicFriction; // Mixed dynamic friction during collision
float staticFriction; // Mixed static friction during collision
} PhysicsManifoldData, *PhysicsManifold;
PHYSACDEF void InitPhysics(void); // Initializes physics system
PHYSACDEF void UpdatePhysics(void); // Update physics system
PHYSACDEF void ResetPhysics(void); // Reset physics system (global variables)
PHYSACDEF void ClosePhysics(void); // Close physics system and unload used memory
PHYSACDEF void SetPhysicsTimeStep(double delta); // Sets physics fixed time step in milliseconds. 1.666666 by default
PHYSACDEF void SetPhysicsGravity(float x, float y); // Sets physics global gravity force
// Physic body creation/destroy
PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density); // Creates a new circle physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density); // Creates a new rectangle physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density); // Creates a new polygon physics body with generic parameters
PHYSACDEF void DestroyPhysicsBody(PhysicsBody body); // Destroy a physics body
// Physic body forces
PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force); // Adds a force to a physics body
PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount); // Adds an angular force to a physics body
PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float force); // Shatters a polygon shape physics body to little physics bodies with explosion force
PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians); // Sets physics body shape transform based on radians parameter
// Query physics info
PHYSACDEF PhysicsBody GetPhysicsBody(int index); // Returns a physics body of the bodies pool at a specific index
PHYSACDEF int GetPhysicsBodiesCount(void); // Returns the current amount of created physics bodies
PHYSACDEF int GetPhysicsShapeType(int index); // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
PHYSACDEF int GetPhysicsShapeVerticesCount(int index); // Returns the amount of vertices of a physics body shape
PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex); // Returns transformed position of a body shape (body position + vertex transformed position)

347
raylib/raygui.h.modified Normal file
View file

@ -0,0 +1,347 @@
/*******************************************************************************************
*
* raygui v3.0-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_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_RICONS
* Includes embedded ricons data (binary format) and definitions (by default 256 16x16 pixels, 2KB)
*
* #define RAYGUI_SUPPORT_CUSTOM_RICONS
* Includes custom ricons.h header defining a set of custom icons,
* this file can be generated using rGuiIcons tool
*
*
* VERSIONS HISTORY:
*
* 3.0-dev (22-Aug-2021) Integrated ricons data to avoid external file
* 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.
*
**********************************************************************************************/
// Define functions scope to be used internally (static) or externally (extern) to the module including this file
// Allow custom memory allocators
//----------------------------------------------------------------------------------
// Types and Structures Definition
// NOTE: Some types are required for RAYGUI_STANDALONE usage
//----------------------------------------------------------------------------------
// Style property
typedef struct GuiStyleProp {
unsigned short controlId;
unsigned short propertyId;
int propertyValue;
} GuiStyleProp;
// Gui control state
typedef enum {
GUI_STATE_NORMAL = 0,
GUI_STATE_FOCUSED,
GUI_STATE_PRESSED,
GUI_STATE_DISABLED,
} GuiControlState;
// Gui control text alignment
typedef enum {
GUI_TEXT_ALIGN_LEFT = 0,
GUI_TEXT_ALIGN_CENTER,
GUI_TEXT_ALIGN_RIGHT,
} GuiTextAlignment;
// Gui controls
typedef enum {
DEFAULT = 0,
LABEL, // LABELBUTTON
BUTTON, // IMAGEBUTTON
TOGGLE, // TOGGLEGROUP
SLIDER, // SLIDERBAR
PROGRESSBAR,
CHECKBOX,
COMBOBOX,
DROPDOWNBOX,
TEXTBOX, // TEXTBOXMULTI
VALUEBOX,
SPINNER,
LISTVIEW,
COLORPICKER,
SCROLLBAR,
STATUSBAR
} GuiControl;
// Gui base properties for every control
typedef 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
} GuiControlProperty;
// Gui extended properties depend on control
// NOTE: We reserve a fixed size of additional properties per control
// DEFAULT properties
typedef enum {
TEXT_SIZE = 16,
TEXT_SPACING,
LINE_COLOR,
BACKGROUND_COLOR,
} GuiDefaultProperty;
// Label
//typedef enum { } GuiLabelProperty;
// Button
//typedef enum { } GuiButtonProperty;
// Toggle / ToggleGroup
typedef enum {
GROUP_PADDING = 16,
} GuiToggleProperty;
// Slider / SliderBar
typedef enum {
SLIDER_WIDTH = 16,
SLIDER_PADDING
} GuiSliderProperty;
// ProgressBar
typedef enum {
PROGRESS_PADDING = 16,
} GuiProgressBarProperty;
// CheckBox
typedef enum {
CHECK_PADDING = 16
} GuiCheckBoxProperty;
// ComboBox
typedef enum {
COMBO_BUTTON_WIDTH = 16,
COMBO_BUTTON_PADDING
} GuiComboBoxProperty;
// DropdownBox
typedef enum {
ARROW_PADDING = 16,
DROPDOWN_ITEMS_PADDING
} GuiDropdownBoxProperty;
// TextBox / TextBoxMulti / ValueBox / Spinner
typedef enum {
TEXT_INNER_PADDING = 16,
TEXT_LINES_PADDING,
COLOR_SELECTED_FG,
COLOR_SELECTED_BG
} GuiTextBoxProperty;
// Spinner
typedef enum {
SPIN_BUTTON_WIDTH = 16,
SPIN_BUTTON_PADDING,
} GuiSpinnerProperty;
// ScrollBar
typedef enum {
ARROWS_SIZE = 16,
ARROWS_VISIBLE,
SCROLL_SLIDER_PADDING,
SCROLL_SLIDER_SIZE,
SCROLL_PADDING,
SCROLL_SPEED,
} GuiScrollBarProperty;
// ScrollBar side
typedef enum {
SCROLLBAR_LEFT_SIDE = 0,
SCROLLBAR_RIGHT_SIDE
} GuiScrollBarSide;
// ListView
typedef enum {
LIST_ITEMS_HEIGHT = 16,
LIST_ITEMS_PADDING,
SCROLLBAR_WIDTH,
SCROLLBAR_SIDE,
} GuiListViewProperty;
// ColorPicker
typedef 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
} GuiColorPickerProperty;
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
// ...
//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
// Global gui state control functions
void GuiEnable(void); // Enable gui controls (global state)
void GuiDisable(void); // Disable gui controls (global state)
void GuiLock(void); // Lock gui controls (global state)
void GuiUnlock(void); // Unlock gui controls (global state)
void GuiFade(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
void GuiSetState(int state); // Set gui state (global state)
int GuiGetState(void); // Get gui state (global state)
// Font set/get functions
void GuiSetFont(Font font); // Set gui custom font (global state)
Font GuiGetFont(void); // Get gui custom font (global state)
// Style set/get functions
void GuiSetStyle(int control, int property, int value); // Set one style property
int GuiGetStyle(int control, int property); // Get one style property
// Container/separator controls, useful for controls organization
bool GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed
void GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name
void GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text
void GuiPanel(Rectangle bounds); // Panel control, useful to group controls
Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll); // Scroll Panel control
// Basic controls set
void GuiLabel(Rectangle bounds, const char *text); // Label control, shows text
bool GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked
bool GuiLabelButton(Rectangle bounds, const char *text); // Label button control, show true when clicked
bool GuiImageButton(Rectangle bounds, const char *text, Texture2D texture); // Image button control, returns true when clicked
bool GuiImageButtonEx(Rectangle bounds, const char *text, Texture2D texture, Rectangle texSource); // Image button extended control, returns true when clicked
bool GuiToggle(Rectangle bounds, const char *text, bool active); // Toggle Button control, returns true when active
int GuiToggleGroup(Rectangle bounds, const char *text, int active); // Toggle Group control, returns active toggle index
bool GuiCheckBox(Rectangle bounds, const char *text, bool checked); // Check Box control, returns true when active
int GuiComboBox(Rectangle bounds, const char *text, int active); // Combo Box control, returns selected item index
bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control, returns selected item
bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control, returns selected value
bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers
bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text
bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control with multiple lines
float GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Slider control, returns selected value
float GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Slider Bar control, returns selected value
float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Progress Bar control, shows current progress value
void GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text
void GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders
int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue); // Scroll Bar control
Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs); // Grid control
// Advance controls set
int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int active); // List View control, returns selected list item index
int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, int *scrollIndex, int active); // List View with extended parameters
int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons); // Message Box control, displays a message
int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text); // Text Input Box control, ask for text
Color GuiColorPicker(Rectangle bounds, Color color); // Color Picker control (multiple color controls)
Color GuiColorPanel(Rectangle bounds, Color color); // Color Panel control
float GuiColorBarAlpha(Rectangle bounds, float alpha); // Color Bar Alpha control
float GuiColorBarHue(Rectangle bounds, float value); // Color Bar Hue control
// Styles loading functions
void GuiLoadStyle(const char *fileName); // Load style file over global style variable (.rgs)
void GuiLoadStyleDefault(void); // Load style default over global style
/*
typedef GuiStyle (unsigned int *)
RAYGUIDEF GuiStyle LoadGuiStyle(const char *fileName); // Load style from file (.rgs)
RAYGUIDEF void UnloadGuiStyle(GuiStyle style); // Unload style
*/
const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported)
/***********************************************************************************
*
* RAYGUI IMPLEMENTATION
*
************************************************************************************/

244
raylib/raygui_modified.h
View file

@ -1,244 +0,0 @@
// Style property
typedef struct GuiStyleProp {
unsigned short controlId;
unsigned short propertyId;
int propertyValue;
} GuiStyleProp;
// Gui control state
typedef enum {
GUI_STATE_NORMAL = 0,
GUI_STATE_FOCUSED,
GUI_STATE_PRESSED,
GUI_STATE_DISABLED,
} GuiControlState;
// Gui control text alignment
typedef enum {
GUI_TEXT_ALIGN_LEFT = 0,
GUI_TEXT_ALIGN_CENTER,
GUI_TEXT_ALIGN_RIGHT,
} GuiTextAlignment;
// Gui controls
typedef enum {
DEFAULT = 0,
LABEL, // LABELBUTTON
BUTTON, // IMAGEBUTTON
TOGGLE, // TOGGLEGROUP
SLIDER, // SLIDERBAR
PROGRESSBAR,
CHECKBOX,
COMBOBOX,
DROPDOWNBOX,
TEXTBOX, // TEXTBOXMULTI
VALUEBOX,
SPINNER,
LISTVIEW,
COLORPICKER,
SCROLLBAR,
STATUSBAR
} GuiControl;
// Gui base properties for every control
typedef 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
} GuiControlProperty;
// Gui extended properties depend on control
// NOTE: We reserve a fixed size of additional properties per control
// DEFAULT properties
typedef enum {
TEXT_SIZE = 16,
TEXT_SPACING,
LINE_COLOR,
BACKGROUND_COLOR,
} GuiDefaultProperty;
// Label
//typedef enum { } GuiLabelProperty;
// Button
//typedef enum { } GuiButtonProperty;
// Toggle / ToggleGroup
typedef enum {
GROUP_PADDING = 16,
} GuiToggleProperty;
// Slider / SliderBar
typedef enum {
SLIDER_WIDTH = 16,
SLIDER_PADDING
} GuiSliderProperty;
// ProgressBar
typedef enum {
PROGRESS_PADDING = 16,
} GuiProgressBarProperty;
// CheckBox
typedef enum {
CHECK_PADDING = 16
} GuiCheckBoxProperty;
// ComboBox
typedef enum {
COMBO_BUTTON_WIDTH = 16,
COMBO_BUTTON_PADDING
} GuiComboBoxProperty;
// DropdownBox
typedef enum {
ARROW_PADDING = 16,
DROPDOWN_ITEMS_PADDING
} GuiDropdownBoxProperty;
// TextBox / TextBoxMulti / ValueBox / Spinner
typedef enum {
TEXT_INNER_PADDING = 16,
TEXT_LINES_PADDING,
COLOR_SELECTED_FG,
COLOR_SELECTED_BG
} GuiTextBoxProperty;
// Spinner
typedef enum {
SPIN_BUTTON_WIDTH = 16,
SPIN_BUTTON_PADDING,
} GuiSpinnerProperty;
// ScrollBar
typedef enum {
ARROWS_SIZE = 16,
ARROWS_VISIBLE,
SCROLL_SLIDER_PADDING,
SCROLL_SLIDER_SIZE,
SCROLL_PADDING,
SCROLL_SPEED,
} GuiScrollBarProperty;
// ScrollBar side
typedef enum {
SCROLLBAR_LEFT_SIDE = 0,
SCROLLBAR_RIGHT_SIDE
} GuiScrollBarSide;
// ListView
typedef enum {
LIST_ITEMS_HEIGHT = 16,
LIST_ITEMS_PADDING,
SCROLLBAR_WIDTH,
SCROLLBAR_SIDE,
} GuiListViewProperty;
// ColorPicker
typedef 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
} GuiColorPickerProperty;
// Global gui state control functions
RAYGUIDEF void GuiEnable(void); // Enable gui controls (global state)
RAYGUIDEF void GuiDisable(void); // Disable gui controls (global state)
RAYGUIDEF void GuiLock(void); // Lock gui controls (global state)
RAYGUIDEF void GuiUnlock(void); // Unlock gui controls (global state)
RAYGUIDEF void GuiFade(float alpha); // Set gui controls alpha (global state), alpha goes from 0.0f to 1.0f
RAYGUIDEF void GuiSetState(int state); // Set gui state (global state)
RAYGUIDEF int GuiGetState(void); // Get gui state (global state)
// Font set/get functions
RAYGUIDEF void GuiSetFont(Font font); // Set gui custom font (global state)
RAYGUIDEF Font GuiGetFont(void); // Get gui custom font (global state)
// Style set/get functions
RAYGUIDEF void GuiSetStyle(int control, int property, int value); // Set one style property
RAYGUIDEF int GuiGetStyle(int control, int property); // Get one style property
// Container/separator controls, useful for controls organization
RAYGUIDEF bool GuiWindowBox(Rectangle bounds, const char *title); // Window Box control, shows a window that can be closed
RAYGUIDEF void GuiGroupBox(Rectangle bounds, const char *text); // Group Box control with text name
RAYGUIDEF void GuiLine(Rectangle bounds, const char *text); // Line separator control, could contain text
RAYGUIDEF void GuiPanel(Rectangle bounds); // Panel control, useful to group controls
RAYGUIDEF Rectangle GuiScrollPanel(Rectangle bounds, Rectangle content, Vector2 *scroll); // Scroll Panel control
// Basic controls set
RAYGUIDEF void GuiLabel(Rectangle bounds, const char *text); // Label control, shows text
RAYGUIDEF bool GuiButton(Rectangle bounds, const char *text); // Button control, returns true when clicked
RAYGUIDEF bool GuiLabelButton(Rectangle bounds, const char *text); // Label button control, show true when clicked
RAYGUIDEF bool GuiImageButton(Rectangle bounds, const char *text, Texture2D texture); // Image button control, returns true when clicked
RAYGUIDEF bool GuiImageButtonEx(Rectangle bounds, const char *text, Texture2D texture, Rectangle texSource); // Image button extended control, returns true when clicked
RAYGUIDEF bool GuiToggle(Rectangle bounds, const char *text, bool active); // Toggle Button control, returns true when active
RAYGUIDEF int GuiToggleGroup(Rectangle bounds, const char *text, int active); // Toggle Group control, returns active toggle index
RAYGUIDEF bool GuiCheckBox(Rectangle bounds, const char *text, bool checked); // Check Box control, returns true when active
RAYGUIDEF int GuiComboBox(Rectangle bounds, const char *text, int active); // Combo Box control, returns selected item index
RAYGUIDEF bool GuiDropdownBox(Rectangle bounds, const char *text, int *active, bool editMode); // Dropdown Box control, returns selected item
RAYGUIDEF bool GuiSpinner(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Spinner control, returns selected value
RAYGUIDEF bool GuiValueBox(Rectangle bounds, const char *text, int *value, int minValue, int maxValue, bool editMode); // Value Box control, updates input text with numbers
RAYGUIDEF bool GuiTextBox(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control, updates input text
RAYGUIDEF bool GuiTextBoxMulti(Rectangle bounds, char *text, int textSize, bool editMode); // Text Box control with multiple lines
RAYGUIDEF float GuiSlider(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Slider control, returns selected value
RAYGUIDEF float GuiSliderBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Slider Bar control, returns selected value
RAYGUIDEF float GuiProgressBar(Rectangle bounds, const char *textLeft, const char *textRight, float value, float minValue, float maxValue); // Progress Bar control, shows current progress value
RAYGUIDEF void GuiStatusBar(Rectangle bounds, const char *text); // Status Bar control, shows info text
RAYGUIDEF void GuiDummyRec(Rectangle bounds, const char *text); // Dummy control for placeholders
RAYGUIDEF int GuiScrollBar(Rectangle bounds, int value, int minValue, int maxValue); // Scroll Bar control
RAYGUIDEF Vector2 GuiGrid(Rectangle bounds, float spacing, int subdivs); // Grid control
// Advance controls set
RAYGUIDEF int GuiListView(Rectangle bounds, const char *text, int *scrollIndex, int active); // List View control, returns selected list item index
RAYGUIDEF int GuiListViewEx(Rectangle bounds, const char **text, int count, int *focus, int *scrollIndex, int active); // List View with extended parameters
RAYGUIDEF int GuiMessageBox(Rectangle bounds, const char *title, const char *message, const char *buttons); // Message Box control, displays a message
RAYGUIDEF int GuiTextInputBox(Rectangle bounds, const char *title, const char *message, const char *buttons, char *text); // Text Input Box control, ask for text
RAYGUIDEF Color GuiColorPicker(Rectangle bounds, Color color); // Color Picker control (multiple color controls)
RAYGUIDEF Color GuiColorPanel(Rectangle bounds, Color color); // Color Panel control
RAYGUIDEF float GuiColorBarAlpha(Rectangle bounds, float alpha); // Color Bar Alpha control
RAYGUIDEF float GuiColorBarHue(Rectangle bounds, float value); // Color Bar Hue control
// Styles loading functions
RAYGUIDEF void GuiLoadStyle(const char *fileName); // Load style file over global style variable (.rgs)
RAYGUIDEF void GuiLoadStyleDefault(void); // Load style default over global style
/*
typedef GuiStyle (unsigned int *)
RAYGUIDEF GuiStyle LoadGuiStyle(const char *fileName); // Load style from file (.rgs)
RAYGUIDEF void UnloadGuiStyle(GuiStyle style); // Unload style
*/
RAYGUIDEF const char *GuiIconText(int iconId, const char *text); // Get text with icon id prepended (if supported)
// Gui icons functionality
RAYGUIDEF void GuiDrawIcon(int iconId, Vector2 position, int pixelSize, Color color);
RAYGUIDEF unsigned int *GuiGetIcons(void); // Get full icons data pointer
RAYGUIDEF unsigned int *GuiGetIconData(int iconId); // Get icon bit data
RAYGUIDEF void GuiSetIconData(int iconId, unsigned int *data); // Set icon bit data
RAYGUIDEF void GuiSetIconPixel(int iconId, int x, int y); // Set icon pixel value
RAYGUIDEF void GuiClearIconPixel(int iconId, int x, int y); // Clear icon pixel value
RAYGUIDEF bool GuiCheckIconPixel(int iconId, int x, int y); // Check icon pixel value

1298
raylib/raylib.h.modified Normal file
View file

File diff suppressed because it is too large Load diff

457
raylib/rlgl.h.modified Normal file
View file

@ -0,0 +1,457 @@
/**********************************************************************************************
*
* rlgl v4.0 - A multi-OpenGL abstraction layer with an immediate-mode style API
*
* An abstraction layer for multiple OpenGL versions (1.1, 2.1, 3.3 Core, ES 2.0)
* that provides a pseudo-OpenGL 1.1 immediate-mode style API (rlVertex, rlTranslate, rlRotate...)
*
* When chosing an OpenGL backend different than OpenGL 1.1, some internal buffer are
* initialized on rlglInit() to accumulate vertex data.
*
* When an internal state change is required all the stored vertex data is renderer in batch,
* additioanlly, rlDrawRenderBatchActive() could be called to force flushing of the batch.
*
* Some additional resources are also loaded for convenience, here the complete list:
* - Default batch (RLGL.defaultBatch): RenderBatch system to accumulate vertex data
* - Default texture (RLGL.defaultTextureId): 1x1 white pixel R8G8B8A8
* - Default shader (RLGL.State.defaultShaderId, RLGL.State.defaultShaderLocs)
*
* Internal buffer (and additional resources) must be manually unloaded calling rlglClose().
*
*
* 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_RENDER_TEXTURES_HINT
* Enable framebuffer objects (fbo) support (enabled by default)
* Some GPUs could not support them despite the OpenGL version
*
* #define RLGL_SHOW_GL_DETAILS_INFO
* Show OpenGL extensions and capabilities detailed logs on init
*
* rlgl capabilities could be customized just defining some internal
* values before library inclusion (default values listed):
*
* #define RL_DEFAULT_BATCH_BUFFER_ELEMENTS 8192 // Default internal render batch elements limits
* #define RL_DEFAULT_BATCH_BUFFERS 1 // Default number of batch buffers (multi-buffering)
* #define RL_DEFAULT_BATCH_DRAWCALLS 256 // Default number of batch draw calls (by state changes: mode, texture)
* #define RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS 4 // Maximum number of textures units that can be activated on batch drawing (SetShaderValueTexture())
*
* #define RL_MAX_MATRIX_STACK_SIZE 32 // Maximum size of internal Matrix stack
* #define RL_MAX_SHADER_LOCATIONS 32 // Maximum number of shader locations supported
* #define RL_CULL_DISTANCE_NEAR 0.01 // Default projection matrix near cull distance
* #define RL_CULL_DISTANCE_FAR 1000.0 // Default projection matrix far cull distance
*
* When loading a shader, the following vertex attribute and uniform
* location names are tried to be set automatically:
*
* #define RL_DEFAULT_SHADER_ATTRIB_NAME_POSITION "vertexPosition" // Binded by default to shader location: 0
* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD "vertexTexCoord" // Binded by default to shader location: 1
* #define RL_DEFAULT_SHADER_ATTRIB_NAME_NORMAL "vertexNormal" // Binded by default to shader location: 2
* #define RL_DEFAULT_SHADER_ATTRIB_NAME_COLOR "vertexColor" // Binded by default to shader location: 3
* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TANGENT "vertexTangent" // Binded by default to shader location: 4
* #define RL_DEFAULT_SHADER_ATTRIB_NAME_TEXCOORD2 "vertexTexCoord2" // Binded by default to shader location: 5
* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MVP "mvp" // model-view-projection matrix
* #define RL_DEFAULT_SHADER_UNIFORM_NAME_VIEW "matView" // view matrix
* #define RL_DEFAULT_SHADER_UNIFORM_NAME_PROJECTION "matProjection" // projection matrix
* #define RL_DEFAULT_SHADER_UNIFORM_NAME_MODEL "matModel" // model matrix
* #define RL_DEFAULT_SHADER_UNIFORM_NAME_NORMAL "matNormal" // normal matrix (transpose(inverse(matModelView))
* #define RL_DEFAULT_SHADER_UNIFORM_NAME_COLOR "colDiffuse" // color diffuse (base tint color, multiplied by texture color)
* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE0 "texture0" // texture0 (texture slot active 0)
* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE1 "texture1" // texture1 (texture slot active 1)
* #define RL_DEFAULT_SHADER_SAMPLER2D_NAME_TEXTURE2 "texture2" // texture2 (texture slot active 2)
*
* DEPENDENCIES:
*
* - OpenGL libraries (depending on platform and OpenGL version selected)
* - GLAD OpenGL extensions loading library (only for OpenGL 3.3 Core)
*
*
* 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.
*
**********************************************************************************************/
// Function specifiers in case library is build/used as a shared library (Windows)
// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
// Function specifiers definition
// Support TRACELOG macros
// Allow custom memory allocators
// 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
// Support framebuffer objects by default
// NOTE: Some driver implementation do not support it, despite they should
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
// Default internal render batch elements limits
// This is the maximum amount of elements (quads) per batch
// NOTE: Be careful with text, every letter maps to a quad
// Internal Matrix stack
// Shader limits
// Projection matrix culling
// Texture parameters (equivalent to OpenGL defines)
// Matrix modes (equivalent to OpenGL)
// Primitive assembly draw modes
// GL equivalent data types
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
typedef enum {
OPENGL_11 = 1,
OPENGL_21,
OPENGL_33,
OPENGL_ES_20
} rlGlVersion;
typedef 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,
} rlFramebufferAttachType;
typedef 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,
} rlFramebufferAttachTextureType;
// Dynamic vertex buffers (position + texcoords + colors + indices arrays)
typedef struct rlVertexBuffer {
int elementCount; // Number of elements in the buffer (QUADS)
float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
unsigned int *indices; // Vertex indices (in case vertex data comes indexed) (6 indices per quad)
unsigned int vaoId; // OpenGL Vertex Array Object id
unsigned int vboId[4]; // OpenGL Vertex Buffer Objects id (4 types of vertex data)
} rlVertexBuffer;
// 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)
typedef struct rlDrawCall {
int mode; // Drawing mode: LINES, TRIANGLES, QUADS
int vertexCount; // Number of vertex of the draw
int vertexAlignment; // Number of vertex required for index alignment (LINES, TRIANGLES)
//unsigned int vaoId; // Vertex array id to be used on the draw -> Using RLGL.currentBatch->vertexBuffer.vaoId
//unsigned int shaderId; // Shader id to be used on the draw -> Using RLGL.currentShaderId
unsigned int textureId; // Texture id to be used on the draw -> Use to create new draw call if changes
//Matrix projection; // Projection matrix for this draw -> Using RLGL.projection by default
//Matrix modelview; // Modelview matrix for this draw -> Using RLGL.modelview by default
} rlDrawCall;
// rlRenderBatch type
typedef struct rlRenderBatch {
int bufferCount; // Number of vertex buffers (multi-buffering support)
int currentBuffer; // Current buffer tracking in case of multi-buffering
rlVertexBuffer *vertexBuffer; // Dynamic buffer(s) for vertex data
rlDrawCall *draws; // Draw calls array, depends on textureId
int drawCounter; // Draw calls counter
float currentDepth; // Current depth value for next draw
} rlRenderBatch;
// Trace log level
// NOTE: Organized by priority level
typedef enum {
RL_LOG_ALL = 0, // Display all logs
RL_LOG_TRACE, // Trace logging, intended for internal use only
RL_LOG_DEBUG, // Debug logging, used for internal debugging, it should be disabled on release builds
RL_LOG_INFO, // Info logging, used for program execution info
RL_LOG_WARNING, // Warning logging, used on recoverable failures
RL_LOG_ERROR, // Error logging, used on unrecoverable failures
RL_LOG_FATAL, // Fatal logging, used to abort program: exit(EXIT_FAILURE)
RL_LOG_NONE // Disable logging
} rlTraceLogLevel;
// Texture formats (support depends on OpenGL version)
typedef enum {
RL_PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
RL_PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
RL_PIXELFORMAT_UNCOMPRESSED_R5G6B5, // 16 bpp
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8, // 24 bpp
RL_PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
RL_PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, // 32 bpp
RL_PIXELFORMAT_UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
RL_PIXELFORMAT_COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
RL_PIXELFORMAT_COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
RL_PIXELFORMAT_COMPRESSED_DXT3_RGBA, // 8 bpp
RL_PIXELFORMAT_COMPRESSED_DXT5_RGBA, // 8 bpp
RL_PIXELFORMAT_COMPRESSED_ETC1_RGB, // 4 bpp
RL_PIXELFORMAT_COMPRESSED_ETC2_RGB, // 4 bpp
RL_PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
RL_PIXELFORMAT_COMPRESSED_PVRT_RGB, // 4 bpp
RL_PIXELFORMAT_COMPRESSED_PVRT_RGBA, // 4 bpp
RL_PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
RL_PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA // 2 bpp
} rlPixelFormat;
// Texture parameters: filter mode
// NOTE 1: Filtering considers mipmaps if available in the texture
// NOTE 2: Filter is accordingly set for minification and magnification
typedef enum {
RL_TEXTURE_FILTER_POINT = 0, // No filter, just pixel aproximation
RL_TEXTURE_FILTER_BILINEAR, // Linear filtering
RL_TEXTURE_FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps)
RL_TEXTURE_FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x
RL_TEXTURE_FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x
RL_TEXTURE_FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x
} rlTextureFilter;
// Color blending modes (pre-defined)
typedef enum {
RL_BLEND_ALPHA = 0, // Blend textures considering alpha (default)
RL_BLEND_ADDITIVE, // Blend textures adding colors
RL_BLEND_MULTIPLIED, // Blend textures multiplying colors
RL_BLEND_ADD_COLORS, // Blend textures adding colors (alternative)
RL_BLEND_SUBTRACT_COLORS, // Blend textures subtracting colors (alternative)
RL_BLEND_CUSTOM // Belnd textures using custom src/dst factors (use SetBlendModeCustom())
} rlBlendMode;
// Shader location point type
typedef enum {
RL_SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
RL_SHADER_LOC_VERTEX_TEXCOORD01, // Shader location: vertex attribute: texcoord01
RL_SHADER_LOC_VERTEX_TEXCOORD02, // Shader location: vertex attribute: texcoord02
RL_SHADER_LOC_VERTEX_NORMAL, // Shader location: vertex attribute: normal
RL_SHADER_LOC_VERTEX_TANGENT, // Shader location: vertex attribute: tangent
RL_SHADER_LOC_VERTEX_COLOR, // Shader location: vertex attribute: color
RL_SHADER_LOC_MATRIX_MVP, // Shader location: matrix uniform: model-view-projection
RL_SHADER_LOC_MATRIX_VIEW, // Shader location: matrix uniform: view (camera transform)
RL_SHADER_LOC_MATRIX_PROJECTION, // Shader location: matrix uniform: projection
RL_SHADER_LOC_MATRIX_MODEL, // Shader location: matrix uniform: model (transform)
RL_SHADER_LOC_MATRIX_NORMAL, // Shader location: matrix uniform: normal
RL_SHADER_LOC_VECTOR_VIEW, // Shader location: vector uniform: view
RL_SHADER_LOC_COLOR_DIFFUSE, // Shader location: vector uniform: diffuse color
RL_SHADER_LOC_COLOR_SPECULAR, // Shader location: vector uniform: specular color
RL_SHADER_LOC_COLOR_AMBIENT, // Shader location: vector uniform: ambient color
RL_SHADER_LOC_MAP_ALBEDO, // Shader location: sampler2d texture: albedo (same as: RL_SHADER_LOC_MAP_DIFFUSE)
RL_SHADER_LOC_MAP_METALNESS, // Shader location: sampler2d texture: metalness (same as: RL_SHADER_LOC_MAP_SPECULAR)
RL_SHADER_LOC_MAP_NORMAL, // Shader location: sampler2d texture: normal
RL_SHADER_LOC_MAP_ROUGHNESS, // Shader location: sampler2d texture: roughness
RL_SHADER_LOC_MAP_OCCLUSION, // Shader location: sampler2d texture: occlusion
RL_SHADER_LOC_MAP_EMISSION, // Shader location: sampler2d texture: emission
RL_SHADER_LOC_MAP_HEIGHT, // Shader location: sampler2d texture: height
RL_SHADER_LOC_MAP_CUBEMAP, // Shader location: samplerCube texture: cubemap
RL_SHADER_LOC_MAP_IRRADIANCE, // Shader location: samplerCube texture: irradiance
RL_SHADER_LOC_MAP_PREFILTER, // Shader location: samplerCube texture: prefilter
RL_SHADER_LOC_MAP_BRDF // Shader location: sampler2d texture: brdf
} rlShaderLocationIndex;
// Shader uniform data type
typedef enum {
RL_SHADER_UNIFORM_FLOAT = 0, // Shader uniform type: float
RL_SHADER_UNIFORM_VEC2, // Shader uniform type: vec2 (2 float)
RL_SHADER_UNIFORM_VEC3, // Shader uniform type: vec3 (3 float)
RL_SHADER_UNIFORM_VEC4, // Shader uniform type: vec4 (4 float)
RL_SHADER_UNIFORM_INT, // Shader uniform type: int
RL_SHADER_UNIFORM_IVEC2, // Shader uniform type: ivec2 (2 int)
RL_SHADER_UNIFORM_IVEC3, // Shader uniform type: ivec3 (3 int)
RL_SHADER_UNIFORM_IVEC4, // Shader uniform type: ivec4 (4 int)
RL_SHADER_UNIFORM_SAMPLER2D // Shader uniform type: sampler2d
} rlShaderUniformDataType;
// Shader attribute data types
typedef enum {
RL_SHADER_ATTRIB_FLOAT = 0, // Shader attribute type: float
RL_SHADER_ATTRIB_VEC2, // Shader attribute type: vec2 (2 float)
RL_SHADER_ATTRIB_VEC3, // Shader attribute type: vec3 (3 float)
RL_SHADER_ATTRIB_VEC4 // Shader attribute type: vec4 (4 float)
} rlShaderAttributeDataType;
//------------------------------------------------------------------------------------
// Functions Declaration - Matrix operations
//------------------------------------------------------------------------------------
void rlMatrixMode(int mode); // Choose the current matrix to be transformed
void rlPushMatrix(void); // Push the current matrix to stack
void rlPopMatrix(void); // Pop lattest inserted matrix from stack
void rlLoadIdentity(void); // Reset current matrix to identity matrix
void rlTranslatef(float x, float y, float z); // Multiply the current matrix by a translation matrix
void rlRotatef(float angle, float x, float y, float z); // Multiply the current matrix by a rotation matrix
void rlScalef(float x, float y, float z); // Multiply the current matrix by a scaling matrix
void rlMultMatrixf(float *matf); // Multiply the current matrix by another matrix
void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar);
void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar);
void rlViewport(int x, int y, int width, int height); // Set the viewport area
//------------------------------------------------------------------------------------
// Functions Declaration - Vertex level operations
//------------------------------------------------------------------------------------
void rlBegin(int mode); // Initialize drawing mode (how to organize vertex)
void rlEnd(void); // Finish vertex providing
void rlVertex2i(int x, int y); // Define one vertex (position) - 2 int
void rlVertex2f(float x, float y); // Define one vertex (position) - 2 float
void rlVertex3f(float x, float y, float z); // Define one vertex (position) - 3 float
void rlTexCoord2f(float x, float y); // Define one vertex (texture coordinate) - 2 float
void rlNormal3f(float x, float y, float z); // Define one vertex (normal) - 3 float
void rlColor4ub(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Define one vertex (color) - 4 byte
void rlColor3f(float x, float y, float z); // Define one vertex (color) - 3 float
void rlColor4f(float x, float y, float z, float w); // 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
bool rlEnableVertexArray(unsigned int vaoId); // Enable vertex array (VAO, if supported)
void rlDisableVertexArray(void); // Disable vertex array (VAO, if supported)
void rlEnableVertexBuffer(unsigned int id); // Enable vertex buffer (VBO)
void rlDisableVertexBuffer(void); // Disable vertex buffer (VBO)
void rlEnableVertexBufferElement(unsigned int id);// Enable vertex buffer element (VBO element)
void rlDisableVertexBufferElement(void); // Disable vertex buffer element (VBO element)
void rlEnableVertexAttribute(unsigned int index); // Enable vertex attribute index
void rlDisableVertexAttribute(unsigned int index);// Disable vertex attribute index
// Textures state
void rlActiveTextureSlot(int slot); // Select and active a texture slot
void rlEnableTexture(unsigned int id); // Enable texture
void rlDisableTexture(void); // Disable texture
void rlEnableTextureCubemap(unsigned int id); // Enable texture cubemap
void rlDisableTextureCubemap(void); // Disable texture cubemap
void rlTextureParameters(unsigned int id, int param, int value); // Set texture parameters (filter, wrap)
// Shader state
void rlEnableShader(unsigned int id); // Enable shader program
void rlDisableShader(void); // Disable shader program
// Framebuffer state
void rlEnableFramebuffer(unsigned int id); // Enable render texture (fbo)
void rlDisableFramebuffer(void); // Disable render texture (fbo), return to default framebuffer
void rlActiveDrawBuffers(int count); // Activate multiple draw color buffers
// General render state
void rlEnableColorBlend(void); // Enable color blending
void rlDisableColorBlend(void); // Disable color blending
void rlEnableDepthTest(void); // Enable depth test
void rlDisableDepthTest(void); // Disable depth test
void rlEnableDepthMask(void); // Enable depth write
void rlDisableDepthMask(void); // Disable depth write
void rlEnableBackfaceCulling(void); // Enable backface culling
void rlDisableBackfaceCulling(void); // Disable backface culling
void rlEnableScissorTest(void); // Enable scissor test
void rlDisableScissorTest(void); // Disable scissor test
void rlScissor(int x, int y, int width, int height); // Scissor test
void rlEnableWireMode(void); // Enable wire mode
void rlDisableWireMode(void); // Disable wire mode
void rlSetLineWidth(float width); // Set the line drawing width
float rlGetLineWidth(void); // Get the line drawing width
void rlEnableSmoothLines(void); // Enable line aliasing
void rlDisableSmoothLines(void); // Disable line aliasing
void rlEnableStereoRender(void); // Enable stereo rendering
void rlDisableStereoRender(void); // Disable stereo rendering
bool rlIsStereoRenderEnabled(void); // Check if stereo render is enabled
void rlClearColor(unsigned char r, unsigned char g, unsigned char b, unsigned char a); // Clear color buffer with color
void rlClearScreenBuffers(void); // Clear used screen buffers (color and depth)
void rlCheckErrors(void); // Check and log OpenGL error codes
void rlSetBlendMode(int mode); // Set blending mode
void rlSetBlendFactors(int glSrcFactor, int glDstFactor, int glEquation); // Set blending mode factor and equation (using OpenGL factors)
//------------------------------------------------------------------------------------
// Functions Declaration - rlgl functionality
//------------------------------------------------------------------------------------
// rlgl initialization functions
void rlglInit(int width, int height); // Initialize rlgl (buffers, shaders, textures, states)
void rlglClose(void); // De-inititialize rlgl (buffers, shaders, textures)
void rlLoadExtensions(void *loader); // Load OpenGL extensions (loader function required)
int rlGetVersion(void); // Get current OpenGL version
int rlGetFramebufferWidth(void); // Get default framebuffer width
int rlGetFramebufferHeight(void); // Get default framebuffer height
unsigned int rlGetTextureIdDefault(void); // Get default texture id
unsigned int rlGetShaderIdDefault(void); // Get default shader id
int *rlGetShaderLocsDefault(void); // Get default shader locations
// 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
rlRenderBatch rlLoadRenderBatch(int numBuffers, int bufferElements); // Load a render batch system
void rlUnloadRenderBatch(rlRenderBatch batch); // Unload render batch system
void rlDrawRenderBatch(rlRenderBatch *batch); // Draw render batch data (Update->Draw->Reset)
void rlSetRenderBatchActive(rlRenderBatch *batch); // Set the active render batch for rlgl (NULL for default internal)
void rlDrawRenderBatchActive(void); // Update and draw internal render batch
bool rlCheckRenderBatchLimit(int vCount); // Check internal buffer overflow for a given number of vertex
void rlSetTexture(unsigned int id); // Set current texture for render batch and check buffers limits
//------------------------------------------------------------------------------------------------------------------------
// Vertex buffers management
unsigned int rlLoadVertexArray(void); // Load vertex array (vao) if supported
unsigned int rlLoadVertexBuffer(void *buffer, int size, bool dynamic); // Load a vertex buffer attribute
unsigned int rlLoadVertexBufferElement(void *buffer, int size, bool dynamic); // Load a new attributes element buffer
void rlUpdateVertexBuffer(unsigned int bufferId, void *data, int dataSize, int offset); // Update GPU buffer with new data
void rlUnloadVertexArray(unsigned int vaoId);
void rlUnloadVertexBuffer(unsigned int vboId);
void rlSetVertexAttribute(unsigned int index, int compSize, int type, bool normalized, int stride, void *pointer);
void rlSetVertexAttributeDivisor(unsigned int index, int divisor);
void rlSetVertexAttributeDefault(int locIndex, const void *value, int attribType, int count); // Set vertex attribute default value
void rlDrawVertexArray(int offset, int count);
void rlDrawVertexArrayElements(int offset, int count, void *buffer);
void rlDrawVertexArrayInstanced(int offset, int count, int instances);
void rlDrawVertexArrayElementsInstanced(int offset, int count, void *buffer, int instances);
// Textures management
unsigned int rlLoadTexture(void *data, int width, int height, int format, int mipmapCount); // Load texture in GPU
unsigned int rlLoadTextureDepth(int width, int height, bool useRenderBuffer); // Load depth texture/renderbuffer (to be attached to fbo)
unsigned int rlLoadTextureCubemap(void *data, int size, int format); // Load texture cubemap
void rlUpdateTexture(unsigned int id, int offsetX, int offsetY, int width, int height, int format, const void *data); // Update GPU texture with new data
void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); // Get OpenGL internal formats
const char *rlGetPixelFormatName(unsigned int format); // Get name string for pixel format
void rlUnloadTexture(unsigned int id); // Unload texture from GPU memory
void rlGenTextureMipmaps(unsigned int id, int width, int height, int format, int *mipmaps); // Generate mipmap data for selected texture
void *rlReadTexturePixels(unsigned int id, int width, int height, int format); // Read texture pixel data
unsigned char *rlReadScreenPixels(int width, int height); // Read screen pixel data (color buffer)
// Framebuffer management (fbo)
unsigned int rlLoadFramebuffer(int width, int height); // Load an empty framebuffer
void rlFramebufferAttach(unsigned int fboId, unsigned int texId, int attachType, int texType, int mipLevel); // Attach texture/renderbuffer to a framebuffer
bool rlFramebufferComplete(unsigned int id); // Verify framebuffer is complete
void rlUnloadFramebuffer(unsigned int id); // Delete framebuffer from GPU
// Shaders management
unsigned int rlLoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings
unsigned int rlCompileShader(const char *shaderCode, int type); // Compile custom shader and return shader id (type: GL_VERTEX_SHADER, GL_FRAGMENT_SHADER)
unsigned int rlLoadShaderProgram(unsigned int vShaderId, unsigned int fShaderId); // Load custom shader program
void rlUnloadShaderProgram(unsigned int id); // Unload shader program
int rlGetLocationUniform(unsigned int shaderId, const char *uniformName); // Get shader location uniform
int rlGetLocationAttrib(unsigned int shaderId, const char *attribName); // Get shader location attribute
void rlSetUniform(int locIndex, const void *value, int uniformType, int count); // Set shader value uniform
void rlSetUniformMatrix(int locIndex, Matrix mat); // Set shader value matrix
void rlSetUniformSampler(int locIndex, unsigned int textureId); // Set shader value sampler
void rlSetShader(unsigned int id, int *locs); // Set shader currently active (id and locations)
// Matrix state management
Matrix rlGetMatrixModelview(void); // Get internal modelview matrix
Matrix rlGetMatrixProjection(void); // Get internal projection matrix
Matrix rlGetMatrixTransform(void); // Get internal accumulated transform matrix
Matrix rlGetMatrixProjectionStereo(int eye); // Get internal projection matrix for stereo render (selected eye)
Matrix rlGetMatrixViewOffsetStereo(int eye); // Get internal view offset matrix for stereo render (selected eye)
void rlSetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
void rlSetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
void rlSetMatrixProjectionStereo(Matrix right, Matrix left); // Set eyes projection matrices for stereo rendering
void rlSetMatrixViewOffsetStereo(Matrix right, Matrix left); // Set eyes view offsets matrices for stereo rendering
// Quick and dirty cube/quad buffers load->draw->unload
void rlLoadDrawCube(void); // Load and draw a cube
void rlLoadDrawQuad(void); // Load and draw a quad
/***********************************************************************************
*
* RLGL IMPLEMENTATION
*
************************************************************************************/

1
setup.py
View file

@ -33,7 +33,6 @@ setup(
"Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.10",
"Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.9",
"Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.8",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.7",
], ],
packages=["raylib", "pyray"], packages=["raylib", "pyray"],

49
tests/raygui_test.py Normal file
View file

@ -0,0 +1,49 @@
from raylib import *
import pyray as pr
screenWidth = 800
screenHeight = 600
SetConfigFlags(FLAG_WINDOW_UNDECORATED)
InitWindow(screenWidth, screenHeight, b"raygui - portable window")
mousePosition = pr.Vector2(0, 0)
windowPosition = pr.Vector2(500, 200 )
panOffset = mousePosition
dragWindow = False
SetWindowPosition(int(windowPosition.x), int(windowPosition.y))
exitWindow = False
SetTargetFPS(60)
while not exitWindow and not WindowShouldClose():
mousePosition = GetMousePosition()
if IsMouseButtonPressed(MOUSE_BUTTON_LEFT):
if CheckCollisionPointRec(mousePosition, pr.Rectangle(0, 0, screenWidth, 20) ):
dragWindow = True
panOffset = mousePosition
if (dragWindow):
windowPosition.x += (mousePosition.x - panOffset.x)
windowPosition.y += (mousePosition.y - panOffset.y)
if IsMouseButtonReleased(MOUSE_BUTTON_LEFT):
dragWindow = False
SetWindowPosition(int(windowPosition.x), int(windowPosition.y))
BeginDrawing()
ClearBackground(RAYWHITE)
exitWindow = GuiWindowBox(pr.Rectangle(0, 0, screenWidth, screenHeight) , b"#198# PORTABLE WINDOW")
pr.draw_text(f"Mouse Position: {mousePosition.x} {mousePosition.y}", 10, 40, 10, DARKGRAY)
EndDrawing()
CloseWindow()

70
tests/test_physac.py Normal file
View file

@ -0,0 +1,70 @@
from raylib import *
screenWidth = 800
screenHeight = 450
SetConfigFlags(FLAG_MSAA_4X_HINT)
InitWindow(screenWidth, screenHeight, b"[physac] Basic demo")
logoX = screenWidth - MeasureText(b"Physac", 30) - 10
logoY = 15
InitPhysics()
floor = CreatePhysicsBodyRectangle([screenWidth/2, screenHeight ], 500, 100, 10)
floor.enabled = False
circle = CreatePhysicsBodyCircle([screenWidth/2, screenHeight/2], 45, 10)
circle.enabled = False
SetTargetFPS(60)
while not WindowShouldClose():
UpdatePhysics();
if IsMouseButtonPressed(MOUSE_BUTTON_LEFT):
body = CreatePhysicsBodyPolygon(GetMousePosition(), GetRandomValue(20, 80), GetRandomValue(3, 8), 10)
elif IsMouseButtonPressed(MOUSE_BUTTON_RIGHT):
CreatePhysicsBodyCircle(GetMousePosition(), GetRandomValue(10, 45), 10)
bodiesCount = GetPhysicsBodiesCount()
for i in range(bodiesCount):
body = GetPhysicsBody(i)
if body and (body.position.y > screenHeight*2):
DestroyPhysicsBody(body)
BeginDrawing()
ClearBackground(BLACK)
DrawFPS(screenWidth - 90, screenHeight - 30)
bodiesCount = GetPhysicsBodiesCount()
for i in range(bodiesCount):
body = GetPhysicsBody(i)
if body:
vertexCount = GetPhysicsShapeVerticesCount(i)
for j in range(vertexCount):
vertexA = GetPhysicsShapeVertex(body, j)
jj = j + 1 if (j + 1) < vertexCount else 0
vertexB = GetPhysicsShapeVertex(body, jj)
DrawLineV(vertexA, vertexB, GREEN)
DrawText(b"Left mouse button to create a polygon", 10, 10, 10, WHITE)
DrawText(b"Right mouse button to create a circle", 10, 25, 10, WHITE)
DrawText(b"Physac", logoX, logoY, 30, WHITE)
DrawText(b"Powered by", logoX + 50, logoY - 7, 10, WHITE)
EndDrawing()
ClosePhysics()
CloseWindow()

76
tests/test_physac2.py Normal file
View file

@ -0,0 +1,76 @@
from raylib import *
VELOCITY = 0.5
screenWidth = 800
screenHeight = 450
SetConfigFlags(FLAG_MSAA_4X_HINT)
InitWindow(screenWidth, screenHeight, b"[physac] Basic demo")
logoX = screenWidth - MeasureText(b"Physac", 30) - 10
logoY = 15
InitPhysics()
floor = CreatePhysicsBodyRectangle([screenWidth/2, screenHeight ], screenWidth, 100, 10)
platformLeft = CreatePhysicsBodyRectangle([screenWidth*0.25, screenHeight*0.6 ], screenWidth*0.25, 10, 10)
platformRight = CreatePhysicsBodyRectangle([screenWidth*0.75, screenHeight*0.6 ], screenWidth*0.25, 10, 10)
wallLeft = CreatePhysicsBodyRectangle([-5, screenHeight/2 ], 10, screenHeight, 10)
wallRight = CreatePhysicsBodyRectangle([screenWidth + 5, screenHeight/2 ], 10, screenHeight, 10)
floor.enabled = False
platformLeft.enabled = False
platformRight.enabled = False
wallLeft.enabled = False
wallRight.enabled = False
body = CreatePhysicsBodyRectangle([screenWidth/2, screenHeight/2 ], 50, 50, 1)
body.freezeOrient = True
SetTargetFPS(60)
while not WindowShouldClose():
UpdatePhysics();
if IsKeyDown(KEY_RIGHT):
body.velocity.x = VELOCITY
elif IsKeyDown(KEY_LEFT):
body.velocity.x = -VELOCITY
if IsKeyDown(KEY_UP) and body.isGrounded:
body.velocity.y = -VELOCITY*4
BeginDrawing()
ClearBackground(BLACK)
DrawFPS(screenWidth - 90, screenHeight - 30)
bodiesCount = GetPhysicsBodiesCount()
for i in range(bodiesCount):
body = GetPhysicsBody(i)
vertexCount = GetPhysicsShapeVerticesCount(i)
for j in range(vertexCount):
vertexA = GetPhysicsShapeVertex(body, j)
jj = j + 1 if j + 1 < vertexCount else 0
vertexB = GetPhysicsShapeVertex(body, jj)
DrawLineV(vertexA, vertexB, GREEN)
DrawText(b"Use 'ARROWS' to move player", 10, 10, 10, WHITE)
DrawText(b"Physac", logoX, logoY, 30, WHITE)
DrawText(b"Powered by", logoX + 50, logoY - 7, 10, WHITE)
EndDrawing()
ClosePhysics()
CloseWindow()

7
tests/test_rlgl.py Normal file
View file

@ -0,0 +1,7 @@
from raylib import *
InitWindow(800, 450, b"rlGL test")
SetTargetFPS(60)
print(rlGetVersion())