clone raylib.zig into libs
This commit is contained in:
parent
e3bed54ab7
commit
01f77a2e4b
3
.gitmodules
vendored
3
.gitmodules
vendored
@ -1,3 +1,6 @@
|
||||
[submodule "libs/zgltf"]
|
||||
path = libs/zgltf
|
||||
url = https://github.com/kooparse/zgltf.git
|
||||
[submodule "libs/raylib/raylib"]
|
||||
path = libs/raylib/raylib
|
||||
url = git@github.com:raysan5/raylib.git
|
||||
|
||||
58
libs/raylib/.gitignore
vendored
Normal file
58
libs/raylib/.gitignore
vendored
Normal file
@ -0,0 +1,58 @@
|
||||
# Prerequisites
|
||||
*.d
|
||||
|
||||
# Object files
|
||||
*.o
|
||||
*.ko
|
||||
*.obj
|
||||
*.elf
|
||||
|
||||
# Linker output
|
||||
*.ilk
|
||||
*.map
|
||||
*.exp
|
||||
|
||||
# Precompiled Headers
|
||||
*.gch
|
||||
*.pch
|
||||
|
||||
# Libraries
|
||||
*.lib
|
||||
*.a
|
||||
*.la
|
||||
*.lo
|
||||
|
||||
# Shared objects (inc. Windows DLLs)
|
||||
*.dll
|
||||
*.so
|
||||
*.so.*
|
||||
*.dylib
|
||||
|
||||
# Executables
|
||||
*.exe
|
||||
*.out
|
||||
*.app
|
||||
*.i*86
|
||||
*.x86_64
|
||||
*.hex
|
||||
|
||||
# Debug files
|
||||
*.dSYM/
|
||||
*.su
|
||||
*.idb
|
||||
*.pdb
|
||||
|
||||
# Kernel Module Compile Results
|
||||
*.mod*
|
||||
*.cmd
|
||||
.tmp_versions/
|
||||
modules.order
|
||||
Module.symvers
|
||||
Mkfile.old
|
||||
dkms.conf
|
||||
|
||||
zig-cache/
|
||||
|
||||
.vscode/settings.json
|
||||
|
||||
.DS_Store
|
||||
21
libs/raylib/LICENSE
Normal file
21
libs/raylib/LICENSE
Normal file
@ -0,0 +1,21 @@
|
||||
MIT License
|
||||
|
||||
Copyright (c) 2022 Michael Scherbakow
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
116
libs/raylib/README.md
Normal file
116
libs/raylib/README.md
Normal file
@ -0,0 +1,116 @@
|
||||
|
||||
|
||||
# raylib.zig
|
||||
Idiomatic [raylib](https://www.raylib.com/) (5.1-dev) bindings for [Zig](https://ziglang.org/) (master).
|
||||
|
||||
[Example Usage](#usage)
|
||||
|
||||
Additional infos and WebGL examples [here](https://github.com/ryupold/examples-raylib.zig).
|
||||
|
||||
## supported platforms
|
||||
- Windows
|
||||
- macOS
|
||||
- Linux
|
||||
- HTML5/WebGL (emscripten)
|
||||
|
||||
## supported APIs
|
||||
- [x] RLAPI (raylib.h)
|
||||
- [x] RLAPI (rlgl.h)
|
||||
- [x] RMAPI (raymath.h)
|
||||
- [x] Constants
|
||||
- [x] int, float, string
|
||||
- [x] Colors
|
||||
- [x] Versions
|
||||
|
||||
For [raygui](https://github.com/raysan5/raygui) bindings see: https://github.com/ryupold/raygui.zig
|
||||
|
||||
## <a id="usage">usage</a>
|
||||
|
||||
The easy way would be adding this as submodule directly in your source folder.
|
||||
Thats what I do until there is an official package manager for Zig.
|
||||
|
||||
```sh
|
||||
cd $YOUR_SRC_FOLDER
|
||||
git submodule add https://github.com/ryupold/raylib.zig raylib
|
||||
git submodule update --init --recursive
|
||||
```
|
||||
|
||||
The bindings have been prebuilt so you just need to add raylib as module
|
||||
|
||||
build.zig:
|
||||
```zig
|
||||
const raylib = @import("path/to/raylib.zig/build.zig");
|
||||
|
||||
pub fn build(b: *std.Build) !void {
|
||||
const target = b.standardTargetOptions(.{});
|
||||
const mode = b.standardOptimizeOption(.{});
|
||||
const exe = ...;
|
||||
raylib.addTo(b, exe, target, mode, .{});
|
||||
}
|
||||
```
|
||||
|
||||
and import in main.zig:
|
||||
```zig
|
||||
const raylib = @import("raylib");
|
||||
|
||||
pub fn main() void {
|
||||
raylib.SetConfigFlags(raylib.ConfigFlags{ .FLAG_WINDOW_RESIZABLE = true });
|
||||
raylib.InitWindow(800, 800, "hello world!");
|
||||
raylib.SetTargetFPS(60);
|
||||
|
||||
defer raylib.CloseWindow();
|
||||
|
||||
while (!raylib.WindowShouldClose()) {
|
||||
raylib.BeginDrawing();
|
||||
defer raylib.EndDrawing();
|
||||
|
||||
raylib.ClearBackground(raylib.BLACK);
|
||||
raylib.DrawFPS(10, 10);
|
||||
|
||||
raylib.DrawText("hello world!", 100, 100, 20, raylib.YELLOW);
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
### WebGL (emscripten) builds
|
||||
|
||||
For Webassembly builds see [examples-raylib.zig/build.zig](https://github.com/ryupold/examples-raylib.zig/blob/main/build.zig)
|
||||
|
||||
This weird workaround with `marshal.h/marshal.c` I actually had to make for Webassembly builds to work, because passing structs as function parameters or returning them cannot be done on the Zig side somehow. If I try it, I get a runtime error "index out of bounds". This happens only in WebAssembly builds. So `marshal.c` must be compiled with `emcc`. See [build.zig](https://github.com/ryupold/examples-raylib.zig/blob/main/build.zig) in the examples.
|
||||
|
||||
## custom definitions
|
||||
An easy way to fix binding mistakes is to edit them in `bindings.json` and setting the custom flag to true. This way the binding will not be overriden when calling `zig build intermediate`.
|
||||
Additionally you can add custom definitions into `inject.zig, inject.h, inject.c` these files will be prepended accordingly.
|
||||
|
||||
## disclaimer
|
||||
I have NOT tested most of the generated functions, so there might be bugs. Especially when it comes to pointers as it is not decidable (for the generator) what a pointer to C means. Could be single item, array, sentinel terminated and/or nullable. If you run into crashes using one of the functions or types in `raylib.zig` feel free to [create an issue](https://github.com/ryupold/raylib.zig/issues) and I will look into it.
|
||||
|
||||
## memory
|
||||
Some of the functions may return pointers to memory allocated within raylib.
|
||||
Usually there will be a corresponding Unload/Free function to dispose it. You cannot use a Zig allocator to free that:
|
||||
|
||||
```zig
|
||||
const data = LoadFileData("test.png");
|
||||
defer UnloadFileData(data);
|
||||
|
||||
// using data...
|
||||
```
|
||||
|
||||
## generate bindings
|
||||
for current raylib source (submodule)
|
||||
|
||||
```sh
|
||||
zig build parse # create JSON files with raylib_parser
|
||||
zig build intermediate # generate bindings.json (keeps definitions with custom=true)
|
||||
zig build bindings # write all intermediate bindings to raylib.zig
|
||||
```
|
||||
|
||||
For easier diffing and to follow changes to the raylib repository I commit also the generated json files.
|
||||
|
||||
## build raylib_parser (executable)
|
||||
If you want to build the raylib_parser executable without a C compiler.
|
||||
```sh
|
||||
zig build raylib_parser
|
||||
```
|
||||
|
||||
you can then find the executable in `./zig-out/bin/`
|
||||
17829
libs/raylib/bindings.json
Normal file
17829
libs/raylib/bindings.json
Normal file
File diff suppressed because it is too large
Load Diff
144
libs/raylib/build.zig
Normal file
144
libs/raylib/build.zig
Normal file
@ -0,0 +1,144 @@
|
||||
const std = @import("std");
|
||||
const generate = @import("generate.zig");
|
||||
|
||||
pub fn build(b: *std.Build) !void {
|
||||
const raylibSrc = "raylib/src/";
|
||||
|
||||
const target = b.standardTargetOptions(.{});
|
||||
|
||||
//--- parse raylib and generate JSONs for all signatures --------------------------------------
|
||||
const jsons = b.step("parse", "parse raylib headers and generate raylib jsons");
|
||||
const raylib_parser_build = b.addExecutable(.{
|
||||
.name = "raylib_parser",
|
||||
.root_source_file = std.build.FileSource.relative("raylib_parser.zig"),
|
||||
.target = target,
|
||||
.optimize = .ReleaseFast,
|
||||
});
|
||||
raylib_parser_build.addCSourceFile(.{ .file = .{ .path = "raylib/parser/raylib_parser.c" }, .flags = &.{} });
|
||||
raylib_parser_build.linkLibC();
|
||||
|
||||
//raylib
|
||||
const raylib_H = b.addRunArtifact(raylib_parser_build);
|
||||
raylib_H.addArgs(&.{
|
||||
"-i", raylibSrc ++ "raylib.h",
|
||||
"-o", "raylib.json",
|
||||
"-f", "JSON",
|
||||
"-d", "RLAPI",
|
||||
});
|
||||
jsons.dependOn(&raylib_H.step);
|
||||
|
||||
//raymath
|
||||
const raymath_H = b.addRunArtifact(raylib_parser_build);
|
||||
raymath_H.addArgs(&.{
|
||||
"-i", raylibSrc ++ "raymath.h",
|
||||
"-o", "raymath.json",
|
||||
"-f", "JSON",
|
||||
"-d", "RMAPI",
|
||||
});
|
||||
jsons.dependOn(&raymath_H.step);
|
||||
|
||||
//rlgl
|
||||
const rlgl_H = b.addRunArtifact(raylib_parser_build);
|
||||
rlgl_H.addArgs(&.{
|
||||
"-i", raylibSrc ++ "rlgl.h",
|
||||
"-o", "rlgl.json",
|
||||
"-f", "JSON",
|
||||
"-d", "RLAPI",
|
||||
});
|
||||
jsons.dependOn(&rlgl_H.step);
|
||||
|
||||
//--- Generate intermediate -------------------------------------------------------------------
|
||||
const intermediate = b.step("intermediate", "generate intermediate representation of the results from 'zig build parse' (keep custom=true)");
|
||||
var intermediateZigStep = b.addRunArtifact(b.addExecutable(.{
|
||||
.name = "intermediate",
|
||||
.root_source_file = std.build.FileSource.relative("intermediate.zig"),
|
||||
.target = target,
|
||||
}));
|
||||
intermediate.dependOn(&intermediateZigStep.step);
|
||||
|
||||
//--- Generate bindings -----------------------------------------------------------------------
|
||||
const bindings = b.step("bindings", "generate bindings in from bindings.json");
|
||||
var generateZigStep = b.addRunArtifact(b.addExecutable(.{
|
||||
.name = "generate",
|
||||
.root_source_file = std.build.FileSource.relative("generate.zig"),
|
||||
.target = target,
|
||||
}));
|
||||
const fmt = b.addFmt(.{ .paths = &.{generate.outputFile} });
|
||||
fmt.step.dependOn(&generateZigStep.step);
|
||||
bindings.dependOn(&fmt.step);
|
||||
|
||||
//--- just build raylib_parser.exe ------------------------------------------------------------
|
||||
const raylib_parser_install = b.step("raylib_parser", "build ./zig-out/bin/raylib_parser.exe");
|
||||
const generateBindings_install = b.addInstallArtifact(raylib_parser_build, .{});
|
||||
raylib_parser_install.dependOn(&generateBindings_install.step);
|
||||
}
|
||||
|
||||
// above: generate library
|
||||
// below: linking (use as dependency)
|
||||
|
||||
fn current_file() []const u8 {
|
||||
return @src().file;
|
||||
}
|
||||
|
||||
const cwd = std.fs.path.dirname(current_file()).?;
|
||||
const sep = std.fs.path.sep_str;
|
||||
const dir_raylib = cwd ++ sep ++ "raylib/src";
|
||||
|
||||
const raylib_build = @import("raylib/src/build.zig");
|
||||
|
||||
fn linkThisLibrary(b: *std.Build, target: std.zig.CrossTarget, optimize: std.builtin.Mode) *std.build.LibExeObjStep {
|
||||
const lib = b.addStaticLibrary(.{ .name = "raylib-zig", .target = target, .optimize = optimize });
|
||||
lib.addIncludePath(.{ .path = dir_raylib });
|
||||
lib.addIncludePath(.{ .path = cwd });
|
||||
lib.linkLibC();
|
||||
lib.addCSourceFile(.{ .file = .{ .path = cwd ++ sep ++ "marshal.c" }, .flags = &.{} });
|
||||
return lib;
|
||||
}
|
||||
|
||||
/// add this package to exe
|
||||
pub fn addTo(b: *std.Build, exe: *std.build.Step.Compile, target: std.zig.CrossTarget, optimize: std.builtin.Mode, raylibOptions: raylib_build.Options) void {
|
||||
exe.addAnonymousModule("raylib", .{ .source_file = .{ .path = cwd ++ sep ++ "raylib.zig" } });
|
||||
exe.addIncludePath(.{ .path = dir_raylib });
|
||||
exe.addIncludePath(.{ .path = cwd });
|
||||
const lib = linkThisLibrary(b, target, optimize);
|
||||
const lib_raylib = raylib_build.addRaylib(b, target, optimize, raylibOptions);
|
||||
exe.linkLibrary(lib_raylib);
|
||||
exe.linkLibrary(lib);
|
||||
}
|
||||
|
||||
pub fn linkSystemDependencies(exe: *std.build.Step.Compile) void {
|
||||
switch (exe.target.getOsTag()) {
|
||||
.macos => {
|
||||
exe.linkFramework("Foundation");
|
||||
exe.linkFramework("Cocoa");
|
||||
exe.linkFramework("OpenGL");
|
||||
exe.linkFramework("CoreAudio");
|
||||
exe.linkFramework("CoreVideo");
|
||||
exe.linkFramework("IOKit");
|
||||
},
|
||||
.linux => {
|
||||
exe.addLibraryPath(.{ .path = "/usr/lib" });
|
||||
exe.addIncludePath(.{ .path = "/usr/include" });
|
||||
exe.linkSystemLibrary("GL");
|
||||
exe.linkSystemLibrary("rt");
|
||||
exe.linkSystemLibrary("dl");
|
||||
exe.linkSystemLibrary("m");
|
||||
exe.linkSystemLibrary("X11");
|
||||
},
|
||||
.freebsd, .openbsd, .netbsd, .dragonfly => {
|
||||
exe.linkSystemLibrary("GL");
|
||||
exe.linkSystemLibrary("rt");
|
||||
exe.linkSystemLibrary("dl");
|
||||
exe.linkSystemLibrary("m");
|
||||
exe.linkSystemLibrary("X11");
|
||||
exe.linkSystemLibrary("Xrandr");
|
||||
exe.linkSystemLibrary("Xinerama");
|
||||
exe.linkSystemLibrary("Xi");
|
||||
exe.linkSystemLibrary("Xxf86vm");
|
||||
exe.linkSystemLibrary("Xcursor");
|
||||
},
|
||||
else => {},
|
||||
}
|
||||
|
||||
exe.linkLibC();
|
||||
}
|
||||
24
libs/raylib/emscripten/entry.c
Normal file
24
libs/raylib/emscripten/entry.c
Normal file
@ -0,0 +1,24 @@
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "emscripten/emscripten.h"
|
||||
#include "raylib.h"
|
||||
|
||||
// Zig compiles C code with -fstack-protector-strong which requires the following two symbols
|
||||
// which don't seem to be provided by the emscripten toolchain(?)
|
||||
void *__stack_chk_guard = (void *)0xdeadbeef;
|
||||
void __stack_chk_fail(void)
|
||||
{
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
// emsc_main() is the Zig entry function in main.zig
|
||||
extern int emsc_main(void);
|
||||
|
||||
extern void emsc_set_window_size(int width, int height);
|
||||
|
||||
int main()
|
||||
{
|
||||
return emsc_main();
|
||||
}
|
||||
96
libs/raylib/emscripten/minshell.html
Normal file
96
libs/raylib/emscripten/minshell.html
Normal file
@ -0,0 +1,96 @@
|
||||
<!DOCTYPE html>
|
||||
<html lang="en-us">
|
||||
|
||||
<head>
|
||||
<meta charset="utf-8" />
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
|
||||
|
||||
<!--no caching for now, the game is still pretty small-->
|
||||
<meta http-equiv="cache-control" content="no-cache" />
|
||||
<meta http-equiv="expires" content="0" />
|
||||
|
||||
<title>demo</title>
|
||||
|
||||
<!-- Favicon -->
|
||||
<link rel="shortcut icon" href="/assets/_favicon.ico" />
|
||||
|
||||
<style>
|
||||
body {
|
||||
background-color: rgb(42, 42, 42);
|
||||
margin: 0px;
|
||||
padding: 8px;
|
||||
display: flex;
|
||||
align-items: center;
|
||||
/* Internet Explorer 10+ */
|
||||
-ms-overflow-style: none;
|
||||
/*Firefox*/
|
||||
scrollbar-width: none;
|
||||
}
|
||||
|
||||
body::-webkit-scrollbar {
|
||||
/*Chrome and Safari*/
|
||||
display: none;
|
||||
}
|
||||
|
||||
canvas.emscripten {
|
||||
border: 0px none;
|
||||
background-color: transparent;
|
||||
}
|
||||
</style>
|
||||
<script>
|
||||
function setResizeInterval(delay, repetitions) {
|
||||
let x = 0;
|
||||
let intervalID = window.setInterval(function () {
|
||||
|
||||
Module.resizeWindow(document.documentElement.clientWidth - 16, document.documentElement.clientHeight - 16);
|
||||
|
||||
if (++x === repetitions) {
|
||||
window.clearInterval(intervalID);
|
||||
}
|
||||
}, delay);
|
||||
}
|
||||
</script>
|
||||
</head>
|
||||
|
||||
<body onload="setResizeInterval(300, 5)"
|
||||
onresize="if(Module.resizeWindow) Module.resizeWindow(document.documentElement.clientWidth-16,document.documentElement.clientHeight-16)">
|
||||
<canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()"
|
||||
tabindex="-1"></canvas>
|
||||
<!-- <p id="output" /> -->
|
||||
<script>
|
||||
var Module = {
|
||||
print: (function () {
|
||||
var element = document.getElementById("output");
|
||||
if (element) element.value = ""; // clear browser cache
|
||||
return function (text) {
|
||||
if (arguments.length > 1)
|
||||
text = Array.prototype.slice.call(arguments).join(" ");
|
||||
console.log(text);
|
||||
if (element) {
|
||||
element.value += text + "\n";
|
||||
element.scrollTop = element.scrollHeight; // focus on bottom
|
||||
}
|
||||
};
|
||||
})(),
|
||||
canvas: (function () {
|
||||
var canvas = document.getElementById("canvas");
|
||||
return canvas;
|
||||
})(),
|
||||
};
|
||||
|
||||
Module.onRuntimeInitialized = function () {
|
||||
Module.resizeWindow = function (w, h) {
|
||||
Module.ccall(
|
||||
"emsc_set_window_size",
|
||||
null,
|
||||
["number", "number"],
|
||||
[w, h]
|
||||
);
|
||||
};
|
||||
Module.resizeWindow(document.documentElement.clientWidth - 16, document.documentElement.clientHeight - 16);
|
||||
};
|
||||
</script>
|
||||
{{{ SCRIPT }}}
|
||||
</body>
|
||||
|
||||
</html>
|
||||
328
libs/raylib/emscripten/shell.html
Normal file
328
libs/raylib/emscripten/shell.html
Normal file
@ -0,0 +1,328 @@
|
||||
<!doctype html>
|
||||
<html lang="en-us">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
|
||||
|
||||
<title>raylib web game</title>
|
||||
|
||||
<meta name="title" content="raylib web game">
|
||||
<meta name="description" content="New raylib web videogame, developed using raylib videogames library">
|
||||
<meta name="keywords" content="raylib, games, html5, programming, C, C++, library, learn, videogames">
|
||||
<meta name="viewport" content="width=device-width">
|
||||
|
||||
<!-- Open Graph metatags for sharing -->
|
||||
<meta property="og:title" content="raylib web game">
|
||||
<meta property="og:image:type" content="image/png">
|
||||
<meta property="og:image" content="https://www.raylib.com/common/img/raylib_logo.png">
|
||||
<meta property="og:site_name" content="raylib.com">
|
||||
<meta property="og:url" content="https://www.raylib.com/games.html">
|
||||
<meta property="og:description" content="New raylib web videogame, developed using raylib videogames library">
|
||||
|
||||
<!-- Twitter metatags for sharing -->
|
||||
<meta name="twitter:card" content="summary">
|
||||
<meta name="twitter:site" content="@raysan5">
|
||||
<meta name="twitter:title" content="raylib web game">
|
||||
<meta name="twitter:image" content="https://www.raylib.com/common/raylib_logo.png">
|
||||
<meta name="twitter:url" content="https://www.raylib.com/games.html">
|
||||
<meta name="twitter:description" content="New raylib web game, developed using raylib videogames library">
|
||||
|
||||
<!-- Favicon -->
|
||||
<link rel="shortcut icon" href="https://www.raylib.com/favicon.ico">
|
||||
|
||||
<style>
|
||||
body {
|
||||
font-family: arial;
|
||||
margin: 0;
|
||||
padding: none;
|
||||
}
|
||||
|
||||
#header {
|
||||
width: 100%;
|
||||
height: 80px;
|
||||
background-color: #888888;
|
||||
}
|
||||
|
||||
/* NOTE: raylib logo is embedded in the page as base64 png image */
|
||||
#logo {
|
||||
width:64px;
|
||||
height:64px;
|
||||
float:left;
|
||||
position:relative;
|
||||
margin:10px;
|
||||
background-image:url('data:image/png;base64,\
|
||||
iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAIAAAAlC+aJAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADs\
|
||||
MAAA7DAcdvqGQAAAAadEVYdFNvZnR3YXJlAFBhaW50Lk5FVCB2My41LjExR/NCNwAAA7JJREFUaEPtk0FyWzEMQ+37X7fZhxX4\
|
||||
YY3AD1OKF1nkzTRlSBCCLeVBnvl/AUdaELOunPno1kts1kixdtEZKVs+xIxebBkZsVknn/L5nFGDLR8T4zVC9fX19S/+tTFijr\
|
||||
YK4jUjbPUtqBHpnEE6PkZD7jQZV8n5Recw1XQKciZuPaEtR6UjNs5ENVGMsBVqpPtER0ZMOhpyp8m4YL4OjD9yxsyZxnQycfMJ\
|
||||
ETNSzsRE1+dihK3YMiJmpHTW3xpmXPC6BXlCHfqnBlsjY5hxf/6EVEOM2BTEi0fYCX4ONSI6Kq3Blg/prIOMq2CsRur4KQ0x64\
|
||||
SdjOufEDEdHZGOhmz5RDHCVqhRuQ86YsVskbc+GXchLiHnFyYH+UigQDVGnImbT8hwFkgLg2qiM8JO6Ylx1FNLa3DmYwqCTsZd\
|
||||
4BPqGJG7MwKzpeiWKTKxXkLMVE3MSOmsdwxLH6Rd/wCCLSNDx6djeKfJuArGeoYamRHpaEjnCBYZVy8hZqo2GI36qPjsiOiMsB\
|
||||
XGcev4Mx9TLGTchbgEjN/uz6jGrBvDjg+LTNx8Qp2CbG2xMKgmOiPslJ4Yxx+eSnSkzlosZNwFPiHl7FRTkLNRJm4+IeVM0ymI\
|
||||
H42wE/wcKalQI4MRl4EW3p6VcRWMua8F6WjIlqZDxvVPiHQ6CjVbYkV9ohhhp/Rk1wiYgpyJ78i4CsZbjkb8Qx+ihvzu3RPaKo\
|
||||
gZkY6GlEeMsKdPSOFIC8VoOusg44L5c+T8ouOoGhWbdWJ8tMi4egkxo4hoh2yNTGf3iIyr5Lyic4bRENXo+lvDjAt4C1Hk/OKt\
|
||||
UaAj0+n4dMSZ2D+hrYJsaYh2SClG2jV9kJKKzhlGQ1SsW299Mq6C8dYZHTExo8fzieI5ivipYnYy7nwJqGKmOYyRwfiUBXITfh\
|
||||
5qSHRGWEkfqJqURgvsdHyWYv7Ko8DnYYegk3EB00cxprdrJRzFd7YQzawu8L1GMTYS/KpPaAFTkIn1EmJmspJSs5xBzSyGhlkB\
|
||||
mlxfNFiP5mw4wlbMh4F5Ddxp5jNINBdCEz9zPOC1zD7Q0HBdmXndwv0TMtydEdzlWJT4VZ8Qt9Qn4/onxMIwa5ZYGJU5yufBiC\
|
||||
jwE50AGjLCVuS8Yt4H7OgZLKK5EKOsLviEWJSL/+0uMi7gLUSBseYwqEbXvSHCec1CJvZPyHCmYQffaBBfOTCGHM2aEbZi1+gO\
|
||||
1XTWVXMnzrhAn5DSOZVsiQlHnSITKzGj6DeTcZWc/3oy7h9//PF4PL4BlvsWrb6RE+oAAAAASUVORK5CYII=');
|
||||
}
|
||||
|
||||
.emscripten { padding-right: 0; margin-left: auto; margin-right: auto; display: block; }
|
||||
div.emscripten { text-align: center; }
|
||||
div.emscripten_border { border: 1px solid black; }
|
||||
|
||||
/* NOTE: Canvas *must not* have any border or padding, or mouse coords will be wrong */
|
||||
canvas.emscripten {
|
||||
border: 0px none;
|
||||
background: black;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
.spinner {
|
||||
height: 30px;
|
||||
width: 30px;
|
||||
margin: 0;
|
||||
margin-top: 20px;
|
||||
margin-left: 20px;
|
||||
display: inline-block;
|
||||
vertical-align: top;
|
||||
-webkit-animation: rotation .8s linear infinite;
|
||||
-moz-animation: rotation .8s linear infinite;
|
||||
-o-animation: rotation .8s linear infinite;
|
||||
animation: rotation 0.8s linear infinite;
|
||||
border-left: 5px solid black;
|
||||
border-right: 5px solid black;
|
||||
border-bottom: 5px solid black;
|
||||
border-top: 5px solid red;
|
||||
border-radius: 100%;
|
||||
background-color: rgb(245, 245, 245);
|
||||
}
|
||||
@-webkit-keyframes rotation {
|
||||
from {-webkit-transform: rotate(0deg);}
|
||||
to {-webkit-transform: rotate(360deg);}
|
||||
}
|
||||
@-moz-keyframes rotation {
|
||||
from {-moz-transform: rotate(0deg);}
|
||||
to {-moz-transform: rotate(360deg);}
|
||||
}
|
||||
@-o-keyframes rotation {
|
||||
from {-o-transform: rotate(0deg);}
|
||||
to {-o-transform: rotate(360deg);}
|
||||
}
|
||||
@keyframes rotation {
|
||||
from {transform: rotate(0deg);}
|
||||
to {transform: rotate(360deg);}
|
||||
}
|
||||
|
||||
#status {
|
||||
display: inline-block;
|
||||
vertical-align: top;
|
||||
margin-top: 30px;
|
||||
margin-left: 20px;
|
||||
font-weight: bold;
|
||||
color: rgb(40, 40, 40);
|
||||
}
|
||||
|
||||
#progress {
|
||||
height: 0px;
|
||||
width: 0px;
|
||||
}
|
||||
|
||||
#controls {
|
||||
display: inline-block;
|
||||
float: right;
|
||||
vertical-align: top;
|
||||
margin-top: 15px;
|
||||
margin-right: 20px;
|
||||
}
|
||||
|
||||
#output {
|
||||
width: 100%;
|
||||
height: 140px;
|
||||
margin: 0 auto;
|
||||
margin-top: 10px;
|
||||
display: block;
|
||||
background-color: black;
|
||||
color: rgb(37, 174, 38);
|
||||
font-family: 'Lucida Console', Monaco, monospace;
|
||||
outline: none;
|
||||
}
|
||||
|
||||
input[type=button] {
|
||||
background-color: lightgray;
|
||||
border: 4px solid darkgray;
|
||||
color: black;
|
||||
text-decoration: none;
|
||||
cursor: pointer;
|
||||
width: 140px;
|
||||
height: 50px;
|
||||
}
|
||||
|
||||
input[type=button]:hover {
|
||||
background-color: #f5f5f5ff;
|
||||
border-color: black;
|
||||
}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div id="header">
|
||||
<a id="logo" href="https://www.raylib.com"></a>
|
||||
|
||||
<div class="spinner" id='spinner'></div>
|
||||
<div class="emscripten" id="status">Downloading...</div>
|
||||
|
||||
<span id='controls'>
|
||||
<span><input type="button" value="🖵 FULLSCREEN" onclick="Module.requestFullscreen(false, false)"></span>
|
||||
<span><input type="button" id="btn-audio" value="🔇 SUSPEND" onclick="toggleAudio()"></span>
|
||||
</span>
|
||||
|
||||
<div class="emscripten">
|
||||
<progress value="0" max="100" id="progress" hidden=1></progress>
|
||||
</div>
|
||||
</div>
|
||||
|
||||
<div class="emscripten_border">
|
||||
<canvas class="emscripten" id="canvas" oncontextmenu="event.preventDefault()" tabindex=-1></canvas>
|
||||
</div>
|
||||
|
||||
<textarea id="output" rows="8"></textarea>
|
||||
|
||||
<script type='text/javascript' src="https://cdn.jsdelivr.net/gh/eligrey/FileSaver.js/dist/FileSaver.min.js"> </script>
|
||||
<script type='text/javascript'>
|
||||
function saveFileFromMEMFSToDisk(memoryFSname, localFSname) // This can be called by C/C++ code
|
||||
{
|
||||
var isSafari = false; // Not supported, navigator.userAgent access is being restricted
|
||||
//var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
|
||||
var data = FS.readFile(memoryFSname);
|
||||
var blob;
|
||||
|
||||
if (isSafari) blob = new Blob([data.buffer], { type: "application/octet-stream" });
|
||||
else blob = new Blob([data.buffer], { type: "application/octet-binary" });
|
||||
|
||||
// NOTE: SaveAsDialog is a browser setting. For example, in Google Chrome,
|
||||
// in Settings/Advanced/Downloads section you have a setting:
|
||||
// 'Ask where to save each file before downloading' - which you can set true/false.
|
||||
// If you enable this setting it would always ask you and bring the SaveAsDialog
|
||||
saveAs(blob, localFSname);
|
||||
}
|
||||
</script>
|
||||
<script type='text/javascript'>
|
||||
var statusElement = document.querySelector('#status');
|
||||
var progressElement = document.querySelector('#progress');
|
||||
var spinnerElement = document.querySelector('#spinner');
|
||||
var Module = {
|
||||
preRun: [],
|
||||
postRun: [],
|
||||
print: (function() {
|
||||
var element = document.querySelector('#output');
|
||||
|
||||
if (element) element.value = ''; // Clear browser cache
|
||||
|
||||
return function(text) {
|
||||
if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' ');
|
||||
// These replacements are necessary if you render to raw HTML
|
||||
//text = text.replace(/&/g, "&");
|
||||
//text = text.replace(/</g, "<");
|
||||
//text = text.replace(/>/g, ">");
|
||||
//text = text.replace('\n', '<br>', 'g');
|
||||
console.log(text);
|
||||
|
||||
if (element) {
|
||||
element.value += text + "\n";
|
||||
element.scrollTop = element.scrollHeight; // focus on bottom
|
||||
}
|
||||
};
|
||||
})(),
|
||||
printErr: function(text) {
|
||||
if (arguments.length > 1) text = Array.prototype.slice.call(arguments).join(' ');
|
||||
|
||||
console.error(text);
|
||||
},
|
||||
canvas: (function() {
|
||||
var canvas = document.querySelector('#canvas');
|
||||
|
||||
// As a default initial behavior, pop up an alert when webgl context is lost.
|
||||
// To make your application robust, you may want to override this behavior before shipping!
|
||||
// See http://www.khronos.org/registry/webgl/specs/latest/1.0/#5.15.2
|
||||
canvas.addEventListener("webglcontextlost", function(e) { alert('WebGL context lost. You will need to reload the page.'); e.preventDefault(); }, false);
|
||||
|
||||
return canvas;
|
||||
})(),
|
||||
setStatus: function(text) {
|
||||
if (!Module.setStatus.last) Module.setStatus.last = { time: Date.now(), text: '' };
|
||||
if (text === Module.setStatus.last.text) return;
|
||||
|
||||
var m = text.match(/([^(]+)\((\d+(\.\d+)?)\/(\d+)\)/);
|
||||
var now = Date.now();
|
||||
|
||||
if (m && now - Module.setStatus.last.time < 30) return; // If this is a progress update, skip it if too soon
|
||||
|
||||
Module.setStatus.last.time = now;
|
||||
Module.setStatus.last.text = text;
|
||||
|
||||
if (m) {
|
||||
text = m[1];
|
||||
progressElement.value = parseInt(m[2])*100;
|
||||
progressElement.max = parseInt(m[4])*100;
|
||||
progressElement.hidden = true;
|
||||
spinnerElement.hidden = false;
|
||||
} else {
|
||||
progressElement.value = null;
|
||||
progressElement.max = null;
|
||||
progressElement.hidden = true;
|
||||
if (!text) spinnerElement.style.display = 'none';
|
||||
}
|
||||
|
||||
statusElement.innerHTML = text;
|
||||
},
|
||||
totalDependencies: 0,
|
||||
monitorRunDependencies: function(left) {
|
||||
this.totalDependencies = Math.max(this.totalDependencies, left);
|
||||
Module.setStatus(left ? 'Preparing... (' + (this.totalDependencies-left) + '/' + this.totalDependencies + ')' : 'All downloads complete.');
|
||||
},
|
||||
//noInitialRun: true
|
||||
};
|
||||
|
||||
Module.setStatus('Downloading...');
|
||||
|
||||
window.onerror = function() {
|
||||
Module.setStatus('Exception thrown, see JavaScript console');
|
||||
spinnerElement.style.display = 'none';
|
||||
Module.setStatus = function(text) { if (text) Module.printErr('[post-exception status] ' + text); };
|
||||
};
|
||||
</script>
|
||||
|
||||
<!-- REF: https://developers.google.com/web/updates/2018/11/web-audio-autoplay -->
|
||||
<script type='text/javascript'>
|
||||
var audioBtn = document.querySelector('#btn-audio');
|
||||
|
||||
// An array of all contexts to resume on the page
|
||||
const audioContexList = [];
|
||||
(function() {
|
||||
// A proxy object to intercept AudioContexts and
|
||||
// add them to the array for tracking and resuming later
|
||||
self.AudioContext = new Proxy(self.AudioContext, {
|
||||
construct(target, args) {
|
||||
const result = new target(...args);
|
||||
audioContexList.push(result);
|
||||
if (result.state == "suspended") audioBtn.value = "🔈 RESUME";
|
||||
return result;
|
||||
}
|
||||
});
|
||||
})();
|
||||
|
||||
function toggleAudio() {
|
||||
var resumed = false;
|
||||
audioContexList.forEach(ctx => {
|
||||
if (ctx.state == "suspended") { ctx.resume(); resumed = true; }
|
||||
else if (ctx.state == "running") ctx.suspend();
|
||||
});
|
||||
|
||||
if (resumed) audioBtn.value = "🔇 SUSPEND";
|
||||
else audioBtn.value = "🔈 RESUME";
|
||||
}
|
||||
</script>
|
||||
{{{ SCRIPT }}}
|
||||
</body>
|
||||
</html>
|
||||
529
libs/raylib/generate.zig
Normal file
529
libs/raylib/generate.zig
Normal file
@ -0,0 +1,529 @@
|
||||
const std = @import("std");
|
||||
const fs = std.fs;
|
||||
const json = std.json;
|
||||
const allocPrint = std.fmt.allocPrint;
|
||||
const mapping = @import("type_mapping.zig");
|
||||
const intermediate = @import("intermediate.zig");
|
||||
|
||||
pub const outputFile = "raylib.zig";
|
||||
pub const injectFile = "inject.zig";
|
||||
|
||||
fn trim(s: []const u8) []const u8 {
|
||||
return std.mem.trim(u8, s, &[_]u8{ ' ', '\t', '\n' });
|
||||
}
|
||||
|
||||
pub fn main() !void {
|
||||
std.log.info("generating raylib.zig ...", .{});
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer {
|
||||
if (gpa.deinit() == .leak) {
|
||||
std.log.err("memory leak detected", .{});
|
||||
}
|
||||
}
|
||||
const allocator = gpa.allocator();
|
||||
var arena = std.heap.ArenaAllocator.init(allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const bindingsData = try fs.cwd().readFileAlloc(arena.allocator(), intermediate.bindingsJSON, std.math.maxInt(usize));
|
||||
|
||||
const bindings = try json.parseFromSliceLeaky(mapping.Intermediate, arena.allocator(), bindingsData, .{
|
||||
.ignore_unknown_fields = true,
|
||||
});
|
||||
|
||||
var file = try fs.cwd().createFile(outputFile, .{});
|
||||
defer file.close();
|
||||
|
||||
try file.writeAll("\n\n");
|
||||
|
||||
const inject = try Injections.load(arena.allocator());
|
||||
try writeInjections(arena.allocator(), &file, inject);
|
||||
|
||||
try writeFunctions(arena.allocator(), &file, bindings, inject);
|
||||
var h = try fs.cwd().createFile("marshal.h", .{});
|
||||
defer h.close();
|
||||
var c = try fs.cwd().createFile("marshal.c", .{});
|
||||
defer c.close();
|
||||
const raylib: mapping.CombinedRaylib = try mapping.CombinedRaylib.load(arena.allocator(), intermediate.jsonFiles);
|
||||
try writeCFunctions(arena.allocator(), &h, &c, inject, raylib);
|
||||
|
||||
try writeStructs(arena.allocator(), &file, bindings, inject);
|
||||
try writeEnums(arena.allocator(), &file, bindings, inject);
|
||||
try writeDefines(arena.allocator(), &file, bindings, inject);
|
||||
|
||||
std.log.info("... done", .{});
|
||||
}
|
||||
|
||||
const Injections = struct {
|
||||
lines: []const []const u8,
|
||||
symbols: []const []const u8,
|
||||
|
||||
pub fn load(allocator: std.mem.Allocator) !@This() {
|
||||
var injectZigLines = std.ArrayList([]const u8).init(allocator);
|
||||
var symbols = std.ArrayList([]const u8).init(allocator);
|
||||
|
||||
var file = try fs.cwd().openFile(injectFile, .{});
|
||||
var reader = file.reader();
|
||||
while (try reader.readUntilDelimiterOrEofAlloc(allocator, '\n', std.math.maxInt(usize))) |line| {
|
||||
if (std.mem.indexOf(u8, line, "pub const ")) |startIndex| {
|
||||
if (std.mem.indexOf(u8, line, " = extern struct {")) |endIndex| {
|
||||
const s = line["pub const ".len + startIndex .. endIndex];
|
||||
try symbols.append(s);
|
||||
std.log.debug("inject symbol: {s}", .{s});
|
||||
} else if (std.mem.indexOf(u8, line, " = packed struct(u32) {")) |endIndex| {
|
||||
const s = line["pub const ".len + startIndex .. endIndex];
|
||||
try symbols.append(s);
|
||||
std.log.debug("inject symbol: {s}", .{s});
|
||||
}
|
||||
}
|
||||
if (std.mem.indexOf(u8, line, "pub fn ")) |startIndex| {
|
||||
if (std.mem.indexOf(u8, line, "(")) |endIndex| {
|
||||
const s = line["pub fn ".len + startIndex .. endIndex];
|
||||
try symbols.append(s);
|
||||
std.log.debug("inject symbol: {s}", .{s});
|
||||
}
|
||||
}
|
||||
try injectZigLines.append(line);
|
||||
}
|
||||
|
||||
return @This(){
|
||||
.lines = try injectZigLines.toOwnedSlice(),
|
||||
.symbols = try symbols.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn containsSymbol(self: @This(), name: []const u8) bool {
|
||||
for (self.symbols) |s| {
|
||||
if (eql(s, name)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
fn writeFunctions(
|
||||
allocator: std.mem.Allocator,
|
||||
file: *fs.File,
|
||||
bindings: mapping.Intermediate,
|
||||
inject: Injections,
|
||||
) !void {
|
||||
var buf: [51200]u8 = undefined;
|
||||
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
||||
|
||||
for (bindings.functions) |func| {
|
||||
if (inject.containsSymbol(func.name)) continue;
|
||||
defer fba.reset();
|
||||
|
||||
//--- signature -------------------------
|
||||
const funcDescription: []const u8 = func.description orelse "";
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"\n/// {s}\npub fn {s} (\n",
|
||||
.{ funcDescription, func.name },
|
||||
),
|
||||
);
|
||||
|
||||
for (func.params) |param| {
|
||||
if (param.description) |description| {
|
||||
try file.writeAll(try allocPrint(
|
||||
allocator,
|
||||
"/// {s}\n",
|
||||
.{description},
|
||||
));
|
||||
}
|
||||
try file.writeAll(try allocPrint(
|
||||
allocator,
|
||||
"{s}: {s},\n",
|
||||
.{ param.name, param.typ },
|
||||
));
|
||||
}
|
||||
|
||||
if (func.custom) {
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
") {s} {{\n",
|
||||
.{func.returnType},
|
||||
),
|
||||
);
|
||||
} else if (isPointer(func.returnType)) {
|
||||
if (eql("u8", (stripType(func.returnType)))) {
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
") [*:0]const {s} {{\n",
|
||||
.{stripType(func.returnType)},
|
||||
),
|
||||
);
|
||||
} else {
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
") {s} {{\n",
|
||||
.{func.returnType},
|
||||
),
|
||||
);
|
||||
}
|
||||
} else {
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
") {s} {{\n",
|
||||
.{func.returnType},
|
||||
),
|
||||
);
|
||||
}
|
||||
const returnTypeIsVoid = eql(func.returnType, "void");
|
||||
|
||||
//--- body ------------------------------
|
||||
if (isPointer(func.returnType)) {
|
||||
try file.writeAll(try allocPrint(allocator, "return @ptrCast({s},\n", .{func.returnType}));
|
||||
} else if (isPrimitiveOrPointer(func.returnType)) {
|
||||
try file.writeAll("return ");
|
||||
} else if (!returnTypeIsVoid) {
|
||||
try file.writeAll(try allocPrint(allocator, "var out: {s} = undefined;\n", .{func.returnType}));
|
||||
}
|
||||
try file.writeAll(try allocPrint(allocator, "raylib.m{s}(\n", .{func.name}));
|
||||
|
||||
if (!isPrimitiveOrPointer(func.returnType)) {
|
||||
if (bindings.containsStruct(stripType(func.returnType))) {
|
||||
try file.writeAll(try allocPrint(allocator, "@ptrCast([*c]raylib.{s}, &out),\n", .{func.returnType}));
|
||||
} else if (!returnTypeIsVoid) {
|
||||
try file.writeAll(try allocPrint(allocator, "@ptrCast([*c]{s}, &out),\n", .{func.returnType}));
|
||||
}
|
||||
}
|
||||
|
||||
for (func.params) |param| {
|
||||
if (isFunctionPointer(param.typ)) {
|
||||
try file.writeAll(try allocPrint(allocator, "@ptrCast({s}),\n", .{param.name}));
|
||||
} else if (bindings.containsStruct(stripType(param.typ)) and isPointer(param.typ)) {
|
||||
try file.writeAll(try allocPrint(allocator, "@intToPtr([*c]raylib.{s}, @ptrToInt({s})),\n", .{ stripType(param.typ), param.name }));
|
||||
} else if (bindings.containsEnum(param.typ)) {
|
||||
try file.writeAll(try allocPrint(allocator, "@enumToInt({s}),\n", .{param.name}));
|
||||
} else if (bindings.containsStruct(stripType(param.typ))) {
|
||||
try file.writeAll(try allocPrint(allocator, "@intToPtr([*c]raylib.{s}, @ptrToInt(&{s})),\n", .{ stripType(param.typ), param.name }));
|
||||
} else if (isPointer(param.typ)) {
|
||||
if (std.mem.endsWith(u8, param.typ, "anyopaque")) {
|
||||
try file.writeAll(try allocPrint(allocator, "{s},\n", .{param.name}));
|
||||
} else if (isConst(param.typ)) {
|
||||
try file.writeAll(try allocPrint(allocator, "@intToPtr([*c]const {s}, @ptrToInt({s})),\n", .{ stripType(param.typ), param.name }));
|
||||
} else {
|
||||
try file.writeAll(try allocPrint(allocator, "@ptrCast([*c]{s}, {s}),\n", .{ stripType(param.typ), param.name }));
|
||||
}
|
||||
} else {
|
||||
try file.writeAll(try allocPrint(allocator, "{s},\n", .{param.name}));
|
||||
}
|
||||
}
|
||||
|
||||
if (isPointer(func.returnType)) {
|
||||
try file.writeAll("),\n);\n");
|
||||
} else {
|
||||
try file.writeAll(");\n");
|
||||
}
|
||||
|
||||
if (!isPrimitiveOrPointer(func.returnType) and !returnTypeIsVoid) {
|
||||
try file.writeAll("return out;\n");
|
||||
}
|
||||
|
||||
try file.writeAll("}\n");
|
||||
}
|
||||
|
||||
std.log.info("generated functions", .{});
|
||||
}
|
||||
|
||||
/// write: RETURN NAME(PARAMS...)
|
||||
/// or: void NAME(RETURN*, PARAMS...)
|
||||
fn writeCSignature(
|
||||
allocator: std.mem.Allocator,
|
||||
file: *fs.File,
|
||||
func: mapping.RaylibFunction,
|
||||
) !void {
|
||||
const returnType = func.returnType;
|
||||
|
||||
//return directly
|
||||
if (mapping.isPrimitiveOrPointer(returnType)) {
|
||||
try file.writeAll(try allocPrint(allocator, "{s} m{s}(", .{ returnType, func.name }));
|
||||
if (func.params == null or func.params.?.len == 0) {
|
||||
try file.writeAll("void");
|
||||
}
|
||||
}
|
||||
//wrap return type and put as first function parameter
|
||||
else {
|
||||
try file.writeAll(try allocPrint(allocator, "void m{s}({s} *out", .{ func.name, returnType }));
|
||||
if (func.params != null and func.params.?.len > 0) {
|
||||
try file.writeAll(", ");
|
||||
}
|
||||
}
|
||||
|
||||
if (func.params) |params| {
|
||||
for (params, 0..) |param, i| {
|
||||
const paramType = param.type;
|
||||
if (mapping.isPrimitiveOrPointer(paramType) or isFunctionPointer(paramType)) {
|
||||
try file.writeAll(try allocPrint(allocator, "{s} {s}", .{ paramType, param.name }));
|
||||
} else {
|
||||
try file.writeAll(try allocPrint(allocator, "{s} *{s}", .{ paramType, param.name }));
|
||||
}
|
||||
|
||||
if (i < params.len - 1) {
|
||||
try file.writeAll(", ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try file.writeAll(")");
|
||||
}
|
||||
|
||||
fn writeCFunctions(
|
||||
allocator: std.mem.Allocator,
|
||||
h: *fs.File,
|
||||
c: *fs.File,
|
||||
inject: Injections,
|
||||
rl: mapping.CombinedRaylib,
|
||||
) !void {
|
||||
var hInject = try fs.cwd().openFile("inject.h", .{});
|
||||
defer hInject.close();
|
||||
try h.writeFileAll(hInject, .{});
|
||||
var cInject = try fs.cwd().openFile("inject.c", .{});
|
||||
defer cInject.close();
|
||||
try c.writeFileAll(cInject, .{});
|
||||
|
||||
for (rl.functions.values()) |func| {
|
||||
if (inject.containsSymbol(func.name)) continue;
|
||||
|
||||
//--- C-HEADER -----------------------------
|
||||
|
||||
try h.writeAll(try allocPrint(allocator, "// {s}\n", .{func.description}));
|
||||
try writeCSignature(allocator, h, func);
|
||||
try h.writeAll(";\n\n");
|
||||
|
||||
try writeCSignature(allocator, c, func);
|
||||
try c.writeAll("\n{\n");
|
||||
|
||||
//--- C-IMPLEMENT -----------------------------
|
||||
|
||||
if (eql(func.returnType, "void")) {
|
||||
try c.writeAll("\t");
|
||||
} else if (mapping.isPrimitiveOrPointer(func.returnType)) {
|
||||
try c.writeAll("\treturn ");
|
||||
} else {
|
||||
try c.writeAll("\t*out = ");
|
||||
}
|
||||
|
||||
try c.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"{s}(",
|
||||
.{func.name},
|
||||
),
|
||||
);
|
||||
|
||||
if (func.params) |params| {
|
||||
for (params, 0..) |param, i| {
|
||||
if (mapping.isPrimitiveOrPointer(param.type) or isFunctionPointer(param.type)) {
|
||||
try c.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"{s}",
|
||||
.{param.name},
|
||||
),
|
||||
);
|
||||
} else {
|
||||
try c.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"*{s}",
|
||||
.{param.name},
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
if (i < params.len - 1) {
|
||||
try c.writeAll(", ");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
try c.writeAll(");\n}\n\n");
|
||||
}
|
||||
}
|
||||
|
||||
fn writeStructs(
|
||||
allocator: std.mem.Allocator,
|
||||
file: *fs.File,
|
||||
bindings: mapping.Intermediate,
|
||||
inject: Injections,
|
||||
) !void {
|
||||
var buf: [51200]u8 = undefined;
|
||||
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
||||
|
||||
for (bindings.structs) |s| {
|
||||
if (inject.containsSymbol(s.name)) continue;
|
||||
defer fba.reset();
|
||||
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"\n/// {?s}\npub const {s} = extern struct {{\n",
|
||||
.{ s.description, s.name },
|
||||
),
|
||||
);
|
||||
|
||||
for (s.fields) |field| {
|
||||
try file.writeAll(try allocPrint(allocator, "/// {?s}\n\t{s}: {s},\n", .{
|
||||
field.description,
|
||||
field.name,
|
||||
field.typ,
|
||||
}));
|
||||
}
|
||||
|
||||
try file.writeAll("\n};\n");
|
||||
}
|
||||
|
||||
std.log.info("generated structs", .{});
|
||||
}
|
||||
|
||||
fn writeEnums(
|
||||
allocator: std.mem.Allocator,
|
||||
file: *fs.File,
|
||||
bindings: mapping.Intermediate,
|
||||
inject: Injections,
|
||||
) !void {
|
||||
var buf: [51200]u8 = undefined;
|
||||
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
||||
|
||||
for (bindings.enums) |e| {
|
||||
if (inject.containsSymbol(e.name)) continue;
|
||||
defer fba.reset();
|
||||
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"\n/// {?s}\npub const {s} = enum(i32) {{\n",
|
||||
.{ e.description, e.name },
|
||||
),
|
||||
);
|
||||
|
||||
for (e.values) |value| {
|
||||
try file.writeAll(try allocPrint(allocator, "/// {?s}\n{s} = {d},\n", .{
|
||||
value.description,
|
||||
value.name,
|
||||
value.value,
|
||||
}));
|
||||
}
|
||||
|
||||
try file.writeAll("\n};\n");
|
||||
}
|
||||
|
||||
std.log.info("generated enums", .{});
|
||||
}
|
||||
|
||||
fn writeDefines(
|
||||
allocator: std.mem.Allocator,
|
||||
file: *fs.File,
|
||||
bindings: mapping.Intermediate,
|
||||
inject: Injections,
|
||||
) !void {
|
||||
var buf: [51200]u8 = undefined;
|
||||
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
||||
|
||||
for (bindings.defines) |d| {
|
||||
if (inject.containsSymbol(d.name)) continue;
|
||||
defer fba.reset();
|
||||
|
||||
try file.writeAll(
|
||||
try allocPrint(
|
||||
allocator,
|
||||
"\n/// {?s}\npub const {s}: {s} = {s};\n",
|
||||
.{ d.description, d.name, d.typ, d.value },
|
||||
),
|
||||
);
|
||||
}
|
||||
|
||||
std.log.info("generated defines", .{});
|
||||
}
|
||||
|
||||
fn writeInjections(
|
||||
_: std.mem.Allocator,
|
||||
file: *fs.File,
|
||||
inject: Injections,
|
||||
) !void {
|
||||
var buf: [51200]u8 = undefined;
|
||||
var fba = std.heap.FixedBufferAllocator.init(&buf);
|
||||
|
||||
for (inject.lines) |line| {
|
||||
defer fba.reset();
|
||||
|
||||
try file.writeAll(try allocPrint(fba.allocator(), "{s}\n", .{line}));
|
||||
}
|
||||
|
||||
std.log.info("written inject.zig", .{});
|
||||
}
|
||||
|
||||
fn eql(a: []const u8, b: []const u8) bool {
|
||||
return std.mem.eql(u8, a, b);
|
||||
}
|
||||
|
||||
fn startsWith(haystack: []const u8, needle: []const u8) bool {
|
||||
return std.mem.startsWith(u8, haystack, needle);
|
||||
}
|
||||
|
||||
fn endsWith(haystack: []const u8, needle: []const u8) bool {
|
||||
return std.mem.endsWith(u8, haystack, needle);
|
||||
}
|
||||
|
||||
/// is pointer type
|
||||
fn isPointer(z: []const u8) bool {
|
||||
return pointerOffset(z) > 0;
|
||||
}
|
||||
|
||||
fn isFunctionPointer(z: []const u8) bool {
|
||||
return std.mem.indexOf(u8, z, "fn(") != null or std.mem.endsWith(u8, z, "Callback");
|
||||
}
|
||||
|
||||
fn pointerOffset(z: []const u8) usize {
|
||||
if (startsWith(z, "*")) return 1;
|
||||
if (startsWith(z, "?*")) return 2;
|
||||
if (startsWith(z, "[*]")) return 3;
|
||||
if (startsWith(z, "?[*]")) return 4;
|
||||
if (startsWith(z, "[*c]")) return 4;
|
||||
if (startsWith(z, "[*:0]")) return 5;
|
||||
if (startsWith(z, "?[*:0]")) return 6;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
fn isConst(z: []const u8) bool {
|
||||
return startsWith(z[pointerOffset(z)..], "const ");
|
||||
}
|
||||
|
||||
fn isVoid(z: []const u8) bool {
|
||||
return eql(stripType(z), "void");
|
||||
}
|
||||
|
||||
/// strips const and pointer annotations
|
||||
/// *const TName -> TName
|
||||
fn stripType(z: []const u8) []const u8 {
|
||||
var name = z[pointerOffset(z)..];
|
||||
name = if (startsWith(name, "const ")) name["const ".len..] else name;
|
||||
|
||||
return std.mem.trim(u8, name, " \t\n");
|
||||
}
|
||||
|
||||
/// true if Zig type is primitive or a pointer to anything
|
||||
/// this means we don't need to wrap it in a pointer
|
||||
pub fn isPrimitiveOrPointer(z: []const u8) bool {
|
||||
const primitiveTypes = std.ComptimeStringMap(void, .{
|
||||
// .{ "void", {} }, // zig void is zero sized while C void is >= 1 byte
|
||||
.{ "bool", {} },
|
||||
.{ "u8", {} },
|
||||
.{ "i8", {} },
|
||||
.{ "i16", {} },
|
||||
.{ "u16", {} },
|
||||
.{ "i32", {} },
|
||||
.{ "u32", {} },
|
||||
.{ "i64", {} },
|
||||
.{ "u64", {} },
|
||||
.{ "f32", {} },
|
||||
.{ "f64", {} },
|
||||
});
|
||||
return primitiveTypes.has(stripType(z)) or pointerOffset(z) > 0;
|
||||
}
|
||||
547
libs/raylib/gui_icons.h
Normal file
547
libs/raylib/gui_icons.h
Normal file
@ -0,0 +1,547 @@
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
// //
|
||||
// raygui Icons exporter v1.1 - Icons data exported as a values array //
|
||||
// //
|
||||
// more info and bugs-report: github.com/raysan5/raygui //
|
||||
// feedback and support: ray[at]raylibtech.com //
|
||||
// //
|
||||
// Copyright (c) 2019-2021 raylib technologies (@raylibtech) //
|
||||
// //
|
||||
//////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Defines and Macros
|
||||
//----------------------------------------------------------------------------------
|
||||
#define RAYGUI_ICON_SIZE 16 // Size of icons (squared)
|
||||
#define RAYGUI_ICON_MAX_ICONS 256 // Maximum number of icons
|
||||
#define RAYGUI_ICON_MAX_NAME_LENGTH 32 // Maximum length of icon name id
|
||||
|
||||
// Icons data is defined by bit array (every bit represents one pixel)
|
||||
// Those arrays are stored as unsigned int data arrays, so every array
|
||||
// element defines 32 pixels (bits) of information
|
||||
// Number of elemens depend on RAYGUI_ICON_SIZE (by default 16x16 pixels)
|
||||
#define RAYGUI_ICON_DATA_ELEMENTS (RAYGUI_ICON_SIZE*RAYGUI_ICON_SIZE/32)
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Icons enumeration
|
||||
//----------------------------------------------------------------------------------
|
||||
typedef enum {
|
||||
RAYGUI_ICON_NONE = 0,
|
||||
RAYGUI_ICON_FOLDER_FILE_OPEN = 1,
|
||||
RAYGUI_ICON_FILE_SAVE_CLASSIC = 2,
|
||||
RAYGUI_ICON_FOLDER_OPEN = 3,
|
||||
RAYGUI_ICON_FOLDER_SAVE = 4,
|
||||
RAYGUI_ICON_FILE_OPEN = 5,
|
||||
RAYGUI_ICON_FILE_SAVE = 6,
|
||||
RAYGUI_ICON_FILE_EXPORT = 7,
|
||||
RAYGUI_ICON_FILE_NEW = 8,
|
||||
RAYGUI_ICON_FILE_DELETE = 9,
|
||||
RAYGUI_ICON_FILETYPE_TEXT = 10,
|
||||
RAYGUI_ICON_FILETYPE_AUDIO = 11,
|
||||
RAYGUI_ICON_FILETYPE_IMAGE = 12,
|
||||
RAYGUI_ICON_FILETYPE_PLAY = 13,
|
||||
RAYGUI_ICON_FILETYPE_VIDEO = 14,
|
||||
RAYGUI_ICON_FILETYPE_INFO = 15,
|
||||
RAYGUI_ICON_FILE_COPY = 16,
|
||||
RAYGUI_ICON_FILE_CUT = 17,
|
||||
RAYGUI_ICON_FILE_PASTE = 18,
|
||||
RAYGUI_ICON_CURSOR_HAND = 19,
|
||||
RAYGUI_ICON_CURSOR_POINTER = 20,
|
||||
RAYGUI_ICON_CURSOR_CLASSIC = 21,
|
||||
RAYGUI_ICON_PENCIL = 22,
|
||||
RAYGUI_ICON_PENCIL_BIG = 23,
|
||||
RAYGUI_ICON_BRUSH_CLASSIC = 24,
|
||||
RAYGUI_ICON_BRUSH_PAINTER = 25,
|
||||
RAYGUI_ICON_WATER_DROP = 26,
|
||||
RAYGUI_ICON_COLOR_PICKER = 27,
|
||||
RAYGUI_ICON_RUBBER = 28,
|
||||
RAYGUI_ICON_COLOR_BUCKET = 29,
|
||||
RAYGUI_ICON_TEXT_T = 30,
|
||||
RAYGUI_ICON_TEXT_A = 31,
|
||||
RAYGUI_ICON_SCALE = 32,
|
||||
RAYGUI_ICON_RESIZE = 33,
|
||||
RAYGUI_ICON_FILTER_POINT = 34,
|
||||
RAYGUI_ICON_FILTER_BILINEAR = 35,
|
||||
RAYGUI_ICON_CROP = 36,
|
||||
RAYGUI_ICON_CROP_ALPHA = 37,
|
||||
RAYGUI_ICON_SQUARE_TOGGLE = 38,
|
||||
RAYGUI_ICON_SIMMETRY = 39,
|
||||
RAYGUI_ICON_SIMMETRY_HORIZONTAL = 40,
|
||||
RAYGUI_ICON_SIMMETRY_VERTICAL = 41,
|
||||
RAYGUI_ICON_LENS = 42,
|
||||
RAYGUI_ICON_LENS_BIG = 43,
|
||||
RAYGUI_ICON_EYE_ON = 44,
|
||||
RAYGUI_ICON_EYE_OFF = 45,
|
||||
RAYGUI_ICON_FILTER_TOP = 46,
|
||||
RAYGUI_ICON_FILTER = 47,
|
||||
RAYGUI_ICON_TARGET_POINT = 48,
|
||||
RAYGUI_ICON_TARGET_SMALL = 49,
|
||||
RAYGUI_ICON_TARGET_BIG = 50,
|
||||
RAYGUI_ICON_TARGET_MOVE = 51,
|
||||
RAYGUI_ICON_CURSOR_MOVE = 52,
|
||||
RAYGUI_ICON_CURSOR_SCALE = 53,
|
||||
RAYGUI_ICON_CURSOR_SCALE_RIGHT = 54,
|
||||
RAYGUI_ICON_CURSOR_SCALE_LEFT = 55,
|
||||
RAYGUI_ICON_UNDO = 56,
|
||||
RAYGUI_ICON_REDO = 57,
|
||||
RAYGUI_ICON_REREDO = 58,
|
||||
RAYGUI_ICON_MUTATE = 59,
|
||||
RAYGUI_ICON_ROTATE = 60,
|
||||
RAYGUI_ICON_REPEAT = 61,
|
||||
RAYGUI_ICON_SHUFFLE = 62,
|
||||
RAYGUI_ICON_EMPTYBOX = 63,
|
||||
RAYGUI_ICON_TARGET = 64,
|
||||
RAYGUI_ICON_TARGET_SMALL_FILL = 65,
|
||||
RAYGUI_ICON_TARGET_BIG_FILL = 66,
|
||||
RAYGUI_ICON_TARGET_MOVE_FILL = 67,
|
||||
RAYGUI_ICON_CURSOR_MOVE_FILL = 68,
|
||||
RAYGUI_ICON_CURSOR_SCALE_FILL = 69,
|
||||
RAYGUI_ICON_CURSOR_SCALE_RIGHT_FILL = 70,
|
||||
RAYGUI_ICON_CURSOR_SCALE_LEFT_FILL = 71,
|
||||
RAYGUI_ICON_UNDO_FILL = 72,
|
||||
RAYGUI_ICON_REDO_FILL = 73,
|
||||
RAYGUI_ICON_REREDO_FILL = 74,
|
||||
RAYGUI_ICON_MUTATE_FILL = 75,
|
||||
RAYGUI_ICON_ROTATE_FILL = 76,
|
||||
RAYGUI_ICON_REPEAT_FILL = 77,
|
||||
RAYGUI_ICON_SHUFFLE_FILL = 78,
|
||||
RAYGUI_ICON_EMPTYBOX_SMALL = 79,
|
||||
RAYGUI_ICON_BOX = 80,
|
||||
RAYGUI_ICON_BOX_TOP = 81,
|
||||
RAYGUI_ICON_BOX_TOP_RIGHT = 82,
|
||||
RAYGUI_ICON_BOX_RIGHT = 83,
|
||||
RAYGUI_ICON_BOX_BOTTOM_RIGHT = 84,
|
||||
RAYGUI_ICON_BOX_BOTTOM = 85,
|
||||
RAYGUI_ICON_BOX_BOTTOM_LEFT = 86,
|
||||
RAYGUI_ICON_BOX_LEFT = 87,
|
||||
RAYGUI_ICON_BOX_TOP_LEFT = 88,
|
||||
RAYGUI_ICON_BOX_CENTER = 89,
|
||||
RAYGUI_ICON_BOX_CIRCLE_MASK = 90,
|
||||
RAYGUI_ICON_POT = 91,
|
||||
RAYGUI_ICON_ALPHA_MULTIPLY = 92,
|
||||
RAYGUI_ICON_ALPHA_CLEAR = 93,
|
||||
RAYGUI_ICON_DITHERING = 94,
|
||||
RAYGUI_ICON_MIPMAPS = 95,
|
||||
RAYGUI_ICON_BOX_GRID = 96,
|
||||
RAYGUI_ICON_GRID = 97,
|
||||
RAYGUI_ICON_BOX_CORNERS_SMALL = 98,
|
||||
RAYGUI_ICON_BOX_CORNERS_BIG = 99,
|
||||
RAYGUI_ICON_FOUR_BOXES = 100,
|
||||
RAYGUI_ICON_GRID_FILL = 101,
|
||||
RAYGUI_ICON_BOX_MULTISIZE = 102,
|
||||
RAYGUI_ICON_ZOOM_SMALL = 103,
|
||||
RAYGUI_ICON_ZOOM_MEDIUM = 104,
|
||||
RAYGUI_ICON_ZOOM_BIG = 105,
|
||||
RAYGUI_ICON_ZOOM_ALL = 106,
|
||||
RAYGUI_ICON_ZOOM_CENTER = 107,
|
||||
RAYGUI_ICON_BOX_DOTS_SMALL = 108,
|
||||
RAYGUI_ICON_BOX_DOTS_BIG = 109,
|
||||
RAYGUI_ICON_BOX_CONCENTRIC = 110,
|
||||
RAYGUI_ICON_BOX_GRID_BIG = 111,
|
||||
RAYGUI_ICON_OK_TICK = 112,
|
||||
RAYGUI_ICON_CROSS = 113,
|
||||
RAYGUI_ICON_ARROW_LEFT = 114,
|
||||
RAYGUI_ICON_ARROW_RIGHT = 115,
|
||||
RAYGUI_ICON_ARROW_BOTTOM = 116,
|
||||
RAYGUI_ICON_ARROW_TOP = 117,
|
||||
RAYGUI_ICON_ARROW_LEFT_FILL = 118,
|
||||
RAYGUI_ICON_ARROW_RIGHT_FILL = 119,
|
||||
RAYGUI_ICON_ARROW_BOTTOM_FILL = 120,
|
||||
RAYGUI_ICON_ARROW_TOP_FILL = 121,
|
||||
RAYGUI_ICON_AUDIO = 122,
|
||||
RAYGUI_ICON_FX = 123,
|
||||
RAYGUI_ICON_WAVE = 124,
|
||||
RAYGUI_ICON_WAVE_SINUS = 125,
|
||||
RAYGUI_ICON_WAVE_SQUARE = 126,
|
||||
RAYGUI_ICON_WAVE_TRIANGULAR = 127,
|
||||
RAYGUI_ICON_CROSS_SMALL = 128,
|
||||
RAYGUI_ICON_PLAYER_PREVIOUS = 129,
|
||||
RAYGUI_ICON_PLAYER_PLAY_BACK = 130,
|
||||
RAYGUI_ICON_PLAYER_PLAY = 131,
|
||||
RAYGUI_ICON_PLAYER_PAUSE = 132,
|
||||
RAYGUI_ICON_PLAYER_STOP = 133,
|
||||
RAYGUI_ICON_PLAYER_NEXT = 134,
|
||||
RAYGUI_ICON_PLAYER_RECORD = 135,
|
||||
RAYGUI_ICON_MAGNET = 136,
|
||||
RAYGUI_ICON_LOCK_CLOSE = 137,
|
||||
RAYGUI_ICON_LOCK_OPEN = 138,
|
||||
RAYGUI_ICON_CLOCK = 139,
|
||||
RAYGUI_ICON_TOOLS = 140,
|
||||
RAYGUI_ICON_GEAR = 141,
|
||||
RAYGUI_ICON_GEAR_BIG = 142,
|
||||
RAYGUI_ICON_BIN = 143,
|
||||
RAYGUI_ICON_HAND_POINTER = 144,
|
||||
RAYGUI_ICON_LASER = 145,
|
||||
RAYGUI_ICON_COIN = 146,
|
||||
RAYGUI_ICON_EXPLOSION = 147,
|
||||
RAYGUI_ICON_1UP = 148,
|
||||
RAYGUI_ICON_PLAYER = 149,
|
||||
RAYGUI_ICON_PLAYER_JUMP = 150,
|
||||
RAYGUI_ICON_KEY = 151,
|
||||
RAYGUI_ICON_DEMON = 152,
|
||||
RAYGUI_ICON_TEXT_POPUP = 153,
|
||||
RAYGUI_ICON_GEAR_EX = 154,
|
||||
RAYGUI_ICON_CRACK = 155,
|
||||
RAYGUI_ICON_CRACK_POINTS = 156,
|
||||
RAYGUI_ICON_STAR = 157,
|
||||
RAYGUI_ICON_DOOR = 158,
|
||||
RAYGUI_ICON_EXIT = 159,
|
||||
RAYGUI_ICON_MODE_2D = 160,
|
||||
RAYGUI_ICON_MODE_3D = 161,
|
||||
RAYGUI_ICON_CUBE = 162,
|
||||
RAYGUI_ICON_CUBE_FACE_TOP = 163,
|
||||
RAYGUI_ICON_CUBE_FACE_LEFT = 164,
|
||||
RAYGUI_ICON_CUBE_FACE_FRONT = 165,
|
||||
RAYGUI_ICON_CUBE_FACE_BOTTOM = 166,
|
||||
RAYGUI_ICON_CUBE_FACE_RIGHT = 167,
|
||||
RAYGUI_ICON_CUBE_FACE_BACK = 168,
|
||||
RAYGUI_ICON_CAMERA = 169,
|
||||
RAYGUI_ICON_SPECIAL = 170,
|
||||
RAYGUI_ICON_LINK_NET = 171,
|
||||
RAYGUI_ICON_LINK_BOXES = 172,
|
||||
RAYGUI_ICON_LINK_MULTI = 173,
|
||||
RAYGUI_ICON_LINK = 174,
|
||||
RAYGUI_ICON_LINK_BROKE = 175,
|
||||
RAYGUI_ICON_TEXT_NOTES = 176,
|
||||
RAYGUI_ICON_NOTEBOOK = 177,
|
||||
RAYGUI_ICON_SUITCASE = 178,
|
||||
RAYGUI_ICON_SUITCASE_ZIP = 179,
|
||||
RAYGUI_ICON_MAILBOX = 180,
|
||||
RAYGUI_ICON_MONITOR = 181,
|
||||
RAYGUI_ICON_PRINTER = 182,
|
||||
RAYGUI_ICON_PHOTO_CAMERA = 183,
|
||||
RAYGUI_ICON_PHOTO_CAMERA_FLASH = 184,
|
||||
RAYGUI_ICON_HOUSE = 185,
|
||||
RAYGUI_ICON_HEART = 186,
|
||||
RAYGUI_ICON_CORNER = 187,
|
||||
RAYGUI_ICON_VERTICAL_BARS = 188,
|
||||
RAYGUI_ICON_VERTICAL_BARS_FILL = 189,
|
||||
RAYGUI_ICON_LIFE_BARS = 190,
|
||||
RAYGUI_ICON_INFO = 191,
|
||||
RAYGUI_ICON_CROSSLINE = 192,
|
||||
RAYGUI_ICON_HELP = 193,
|
||||
RAYGUI_ICON_FILETYPE_ALPHA = 194,
|
||||
RAYGUI_ICON_FILETYPE_HOME = 195,
|
||||
RAYGUI_ICON_LAYERS_VISIBLE = 196,
|
||||
RAYGUI_ICON_LAYERS = 197,
|
||||
RAYGUI_ICON_WINDOW = 198,
|
||||
RAYGUI_ICON_199 = 199,
|
||||
RAYGUI_ICON_200 = 200,
|
||||
RAYGUI_ICON_201 = 201,
|
||||
RAYGUI_ICON_202 = 202,
|
||||
RAYGUI_ICON_203 = 203,
|
||||
RAYGUI_ICON_204 = 204,
|
||||
RAYGUI_ICON_205 = 205,
|
||||
RAYGUI_ICON_206 = 206,
|
||||
RAYGUI_ICON_207 = 207,
|
||||
RAYGUI_ICON_208 = 208,
|
||||
RAYGUI_ICON_209 = 209,
|
||||
RAYGUI_ICON_210 = 210,
|
||||
RAYGUI_ICON_211 = 211,
|
||||
RAYGUI_ICON_212 = 212,
|
||||
RAYGUI_ICON_213 = 213,
|
||||
RAYGUI_ICON_214 = 214,
|
||||
RAYGUI_ICON_215 = 215,
|
||||
RAYGUI_ICON_216 = 216,
|
||||
RAYGUI_ICON_217 = 217,
|
||||
RAYGUI_ICON_218 = 218,
|
||||
RAYGUI_ICON_219 = 219,
|
||||
RAYGUI_ICON_220 = 220,
|
||||
RAYGUI_ICON_221 = 221,
|
||||
RAYGUI_ICON_222 = 222,
|
||||
RAYGUI_ICON_223 = 223,
|
||||
RAYGUI_ICON_224 = 224,
|
||||
RAYGUI_ICON_225 = 225,
|
||||
RAYGUI_ICON_226 = 226,
|
||||
RAYGUI_ICON_227 = 227,
|
||||
RAYGUI_ICON_228 = 228,
|
||||
RAYGUI_ICON_229 = 229,
|
||||
RAYGUI_ICON_230 = 230,
|
||||
RAYGUI_ICON_231 = 231,
|
||||
RAYGUI_ICON_232 = 232,
|
||||
RAYGUI_ICON_233 = 233,
|
||||
RAYGUI_ICON_234 = 234,
|
||||
RAYGUI_ICON_235 = 235,
|
||||
RAYGUI_ICON_236 = 236,
|
||||
RAYGUI_ICON_237 = 237,
|
||||
RAYGUI_ICON_238 = 238,
|
||||
RAYGUI_ICON_239 = 239,
|
||||
RAYGUI_ICON_240 = 240,
|
||||
RAYGUI_ICON_241 = 241,
|
||||
RAYGUI_ICON_242 = 242,
|
||||
RAYGUI_ICON_243 = 243,
|
||||
RAYGUI_ICON_244 = 244,
|
||||
RAYGUI_ICON_245 = 245,
|
||||
RAYGUI_ICON_246 = 246,
|
||||
RAYGUI_ICON_247 = 247,
|
||||
RAYGUI_ICON_248 = 248,
|
||||
RAYGUI_ICON_249 = 249,
|
||||
RAYGUI_ICON_250 = 250,
|
||||
RAYGUI_ICON_251 = 251,
|
||||
RAYGUI_ICON_252 = 252,
|
||||
RAYGUI_ICON_253 = 253,
|
||||
RAYGUI_ICON_254 = 254,
|
||||
RAYGUI_ICON_255 = 255,
|
||||
} guiIconName;
|
||||
|
||||
//----------------------------------------------------------------------------------
|
||||
// Icons data
|
||||
//----------------------------------------------------------------------------------
|
||||
static unsigned int guiIcons[RAYGUI_ICON_MAX_ICONS*RAYGUI_ICON_DATA_ELEMENTS] = {
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_NONE
|
||||
0x3ff80000, 0x2f082008, 0x2042207e, 0x40027fc2, 0x40024002, 0x40024002, 0x40024002, 0x00007ffe, // RAYGUI_ICON_FOLDER_FILE_OPEN
|
||||
0x3ffe0000, 0x44226422, 0x400247e2, 0x5ffa4002, 0x57ea500a, 0x500a500a, 0x40025ffa, 0x00007ffe, // RAYGUI_ICON_FILE_SAVE_CLASSIC
|
||||
0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024002, 0x44424282, 0x793e4102, 0x00000100, // RAYGUI_ICON_FOLDER_OPEN
|
||||
0x00000000, 0x0042007e, 0x40027fc2, 0x40024002, 0x41024102, 0x44424102, 0x793e4282, 0x00000000, // RAYGUI_ICON_FOLDER_SAVE
|
||||
0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x24442284, 0x21042104, 0x20042104, 0x00003ffc, // RAYGUI_ICON_FILE_OPEN
|
||||
0x3ff00000, 0x201c2010, 0x20042004, 0x21042004, 0x21042104, 0x22842444, 0x20042104, 0x00003ffc, // RAYGUI_ICON_FILE_SAVE
|
||||
0x3ff00000, 0x201c2010, 0x00042004, 0x20041004, 0x20844784, 0x00841384, 0x20042784, 0x00003ffc, // RAYGUI_ICON_FILE_EXPORT
|
||||
0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x22042204, 0x22042f84, 0x20042204, 0x00003ffc, // RAYGUI_ICON_FILE_NEW
|
||||
0x3ff00000, 0x201c2010, 0x20042004, 0x20042004, 0x25042884, 0x25042204, 0x20042884, 0x00003ffc, // RAYGUI_ICON_FILE_DELETE
|
||||
0x3ff00000, 0x201c2010, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // RAYGUI_ICON_FILETYPE_TEXT
|
||||
0x3ff00000, 0x201c2010, 0x27042004, 0x244424c4, 0x26442444, 0x20642664, 0x20042004, 0x00003ffc, // RAYGUI_ICON_FILETYPE_AUDIO
|
||||
0x3ff00000, 0x201c2010, 0x26042604, 0x20042004, 0x35442884, 0x2414222c, 0x20042004, 0x00003ffc, // RAYGUI_ICON_FILETYPE_IMAGE
|
||||
0x3ff00000, 0x201c2010, 0x20c42004, 0x22442144, 0x22442444, 0x20c42144, 0x20042004, 0x00003ffc, // RAYGUI_ICON_FILETYPE_PLAY
|
||||
0x3ff00000, 0x3ffc2ff0, 0x3f3c2ff4, 0x3dbc2eb4, 0x3dbc2bb4, 0x3f3c2eb4, 0x3ffc2ff4, 0x00002ff4, // RAYGUI_ICON_FILETYPE_VIDEO
|
||||
0x3ff00000, 0x201c2010, 0x21842184, 0x21842004, 0x21842184, 0x21842184, 0x20042184, 0x00003ffc, // RAYGUI_ICON_FILETYPE_INFO
|
||||
0x0ff00000, 0x381c0810, 0x28042804, 0x28042804, 0x28042804, 0x28042804, 0x20102ffc, 0x00003ff0, // RAYGUI_ICON_FILE_COPY
|
||||
0x00000000, 0x701c0000, 0x079c1e14, 0x55a000f0, 0x079c00f0, 0x701c1e14, 0x00000000, 0x00000000, // RAYGUI_ICON_FILE_CUT
|
||||
0x01c00000, 0x13e41bec, 0x3f841004, 0x204420c4, 0x20442044, 0x20442044, 0x207c2044, 0x00003fc0, // RAYGUI_ICON_FILE_PASTE
|
||||
0x00000000, 0x3aa00fe0, 0x2abc2aa0, 0x2aa42aa4, 0x20042aa4, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_CURSOR_HAND
|
||||
0x00000000, 0x003c000c, 0x030800c8, 0x30100c10, 0x10202020, 0x04400840, 0x01800280, 0x00000000, // RAYGUI_ICON_CURSOR_POINTER
|
||||
0x00000000, 0x00180000, 0x01f00078, 0x03e007f0, 0x07c003e0, 0x04000e40, 0x00000000, 0x00000000, // RAYGUI_ICON_CURSOR_CLASSIC
|
||||
0x00000000, 0x04000000, 0x11000a00, 0x04400a80, 0x01100220, 0x00580088, 0x00000038, 0x00000000, // RAYGUI_ICON_PENCIL
|
||||
0x04000000, 0x15000a00, 0x50402880, 0x14102820, 0x05040a08, 0x015c028c, 0x007c00bc, 0x00000000, // RAYGUI_ICON_PENCIL_BIG
|
||||
0x01c00000, 0x01400140, 0x01400140, 0x0ff80140, 0x0ff80808, 0x0aa80808, 0x0aa80aa8, 0x00000ff8, // RAYGUI_ICON_BRUSH_CLASSIC
|
||||
0x1ffc0000, 0x5ffc7ffe, 0x40004000, 0x00807f80, 0x01c001c0, 0x01c001c0, 0x01c001c0, 0x00000080, // RAYGUI_ICON_BRUSH_PAINTER
|
||||
0x00000000, 0x00800000, 0x01c00080, 0x03e001c0, 0x07f003e0, 0x036006f0, 0x000001c0, 0x00000000, // RAYGUI_ICON_WATER_DROP
|
||||
0x00000000, 0x3e003800, 0x1f803f80, 0x0c201e40, 0x02080c10, 0x00840104, 0x00380044, 0x00000000, // RAYGUI_ICON_COLOR_PICKER
|
||||
0x00000000, 0x07800300, 0x1fe00fc0, 0x3f883fd0, 0x0e021f04, 0x02040402, 0x00f00108, 0x00000000, // RAYGUI_ICON_RUBBER
|
||||
0x00c00000, 0x02800140, 0x08200440, 0x20081010, 0x2ffe3004, 0x03f807fc, 0x00e001f0, 0x00000040, // RAYGUI_ICON_COLOR_BUCKET
|
||||
0x00000000, 0x21843ffc, 0x01800180, 0x01800180, 0x01800180, 0x01800180, 0x03c00180, 0x00000000, // RAYGUI_ICON_TEXT_T
|
||||
0x00800000, 0x01400180, 0x06200340, 0x0c100620, 0x1ff80c10, 0x380c1808, 0x70067004, 0x0000f80f, // RAYGUI_ICON_TEXT_A
|
||||
0x78000000, 0x50004000, 0x00004800, 0x03c003c0, 0x03c003c0, 0x00100000, 0x0002000a, 0x0000000e, // RAYGUI_ICON_SCALE
|
||||
0x75560000, 0x5e004002, 0x54001002, 0x41001202, 0x408200fe, 0x40820082, 0x40820082, 0x00006afe, // RAYGUI_ICON_RESIZE
|
||||
0x00000000, 0x3f003f00, 0x3f003f00, 0x3f003f00, 0x00400080, 0x001c0020, 0x001c001c, 0x00000000, // RAYGUI_ICON_FILTER_POINT
|
||||
0x6d800000, 0x00004080, 0x40804080, 0x40800000, 0x00406d80, 0x001c0020, 0x001c001c, 0x00000000, // RAYGUI_ICON_FILTER_BILINEAR
|
||||
0x40080000, 0x1ffe2008, 0x14081008, 0x11081208, 0x10481088, 0x10081028, 0x10047ff8, 0x00001002, // RAYGUI_ICON_CROP
|
||||
0x00100000, 0x3ffc0010, 0x2ab03550, 0x22b02550, 0x20b02150, 0x20302050, 0x2000fff0, 0x00002000, // RAYGUI_ICON_CROP_ALPHA
|
||||
0x40000000, 0x1ff82000, 0x04082808, 0x01082208, 0x00482088, 0x00182028, 0x35542008, 0x00000002, // RAYGUI_ICON_SQUARE_TOGGLE
|
||||
0x00000000, 0x02800280, 0x06c006c0, 0x0ea00ee0, 0x1e901eb0, 0x3e883e98, 0x7efc7e8c, 0x00000000, // RAYGUI_ICON_SIMMETRY
|
||||
0x01000000, 0x05600100, 0x1d480d50, 0x7d423d44, 0x3d447d42, 0x0d501d48, 0x01000560, 0x00000100, // RAYGUI_ICON_SIMMETRY_HORIZONTAL
|
||||
0x01800000, 0x04200240, 0x10080810, 0x00001ff8, 0x00007ffe, 0x0ff01ff8, 0x03c007e0, 0x00000180, // RAYGUI_ICON_SIMMETRY_VERTICAL
|
||||
0x00000000, 0x010800f0, 0x02040204, 0x02040204, 0x07f00308, 0x1c000e00, 0x30003800, 0x00000000, // RAYGUI_ICON_LENS
|
||||
0x00000000, 0x061803f0, 0x08240c0c, 0x08040814, 0x0c0c0804, 0x23f01618, 0x18002400, 0x00000000, // RAYGUI_ICON_LENS_BIG
|
||||
0x00000000, 0x00000000, 0x1c7007c0, 0x638e3398, 0x1c703398, 0x000007c0, 0x00000000, 0x00000000, // RAYGUI_ICON_EYE_ON
|
||||
0x00000000, 0x10002000, 0x04700fc0, 0x610e3218, 0x1c703098, 0x001007a0, 0x00000008, 0x00000000, // RAYGUI_ICON_EYE_OFF
|
||||
0x00000000, 0x00007ffc, 0x40047ffc, 0x10102008, 0x04400820, 0x02800280, 0x02800280, 0x00000100, // RAYGUI_ICON_FILTER_TOP
|
||||
0x00000000, 0x40027ffe, 0x10082004, 0x04200810, 0x02400240, 0x02400240, 0x01400240, 0x000000c0, // RAYGUI_ICON_FILTER
|
||||
0x00800000, 0x00800080, 0x00000080, 0x3c9e0000, 0x00000000, 0x00800080, 0x00800080, 0x00000000, // RAYGUI_ICON_TARGET_POINT
|
||||
0x00800000, 0x00800080, 0x00800080, 0x3f7e01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // RAYGUI_ICON_TARGET_SMALL
|
||||
0x00800000, 0x00800080, 0x03e00080, 0x3e3e0220, 0x03e00220, 0x00800080, 0x00800080, 0x00000000, // RAYGUI_ICON_TARGET_BIG
|
||||
0x01000000, 0x04400280, 0x01000100, 0x43842008, 0x43849ab2, 0x01002008, 0x04400100, 0x01000280, // RAYGUI_ICON_TARGET_MOVE
|
||||
0x01000000, 0x04400280, 0x01000100, 0x41042108, 0x41049ff2, 0x01002108, 0x04400100, 0x01000280, // RAYGUI_ICON_CURSOR_MOVE
|
||||
0x781e0000, 0x500a4002, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x4002500a, 0x0000781e, // RAYGUI_ICON_CURSOR_SCALE
|
||||
0x00000000, 0x20003c00, 0x24002800, 0x01000200, 0x00400080, 0x00140024, 0x003c0004, 0x00000000, // RAYGUI_ICON_CURSOR_SCALE_RIGHT
|
||||
0x00000000, 0x0004003c, 0x00240014, 0x00800040, 0x02000100, 0x28002400, 0x3c002000, 0x00000000, // RAYGUI_ICON_CURSOR_SCALE_LEFT
|
||||
0x00000000, 0x00100020, 0x10101fc8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // RAYGUI_ICON_UNDO
|
||||
0x00000000, 0x08000400, 0x080813f8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // RAYGUI_ICON_REDO
|
||||
0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3f902020, 0x00400020, 0x00000000, // RAYGUI_ICON_REREDO
|
||||
0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3fc82010, 0x00200010, 0x00000000, // RAYGUI_ICON_MUTATE
|
||||
0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18101020, 0x00100fc8, 0x00000020, // RAYGUI_ICON_ROTATE
|
||||
0x00000000, 0x04000200, 0x240429fc, 0x20042204, 0x20442004, 0x3f942024, 0x00400020, 0x00000000, // RAYGUI_ICON_REPEAT
|
||||
0x00000000, 0x20001000, 0x22104c0e, 0x00801120, 0x11200040, 0x4c0e2210, 0x10002000, 0x00000000, // RAYGUI_ICON_SHUFFLE
|
||||
0x7ffe0000, 0x50024002, 0x44024802, 0x41024202, 0x40424082, 0x40124022, 0x4002400a, 0x00007ffe, // RAYGUI_ICON_EMPTYBOX
|
||||
0x00800000, 0x03e00080, 0x08080490, 0x3c9e0808, 0x08080808, 0x03e00490, 0x00800080, 0x00000000, // RAYGUI_ICON_TARGET
|
||||
0x00800000, 0x00800080, 0x00800080, 0x3ffe01c0, 0x008001c0, 0x00800080, 0x00800080, 0x00000000, // RAYGUI_ICON_TARGET_SMALL_FILL
|
||||
0x00800000, 0x00800080, 0x03e00080, 0x3ffe03e0, 0x03e003e0, 0x00800080, 0x00800080, 0x00000000, // RAYGUI_ICON_TARGET_BIG_FILL
|
||||
0x01000000, 0x07c00380, 0x01000100, 0x638c2008, 0x638cfbbe, 0x01002008, 0x07c00100, 0x01000380, // RAYGUI_ICON_TARGET_MOVE_FILL
|
||||
0x01000000, 0x07c00380, 0x01000100, 0x610c2108, 0x610cfffe, 0x01002108, 0x07c00100, 0x01000380, // RAYGUI_ICON_CURSOR_MOVE_FILL
|
||||
0x781e0000, 0x6006700e, 0x04204812, 0x00000240, 0x02400000, 0x48120420, 0x700e6006, 0x0000781e, // RAYGUI_ICON_CURSOR_SCALE_FILL
|
||||
0x00000000, 0x38003c00, 0x24003000, 0x01000200, 0x00400080, 0x000c0024, 0x003c001c, 0x00000000, // RAYGUI_ICON_CURSOR_SCALE_RIGHT_FILL
|
||||
0x00000000, 0x001c003c, 0x0024000c, 0x00800040, 0x02000100, 0x30002400, 0x3c003800, 0x00000000, // RAYGUI_ICON_CURSOR_SCALE_LEFT_FILL
|
||||
0x00000000, 0x00300020, 0x10301ff8, 0x10001020, 0x10001000, 0x10001000, 0x00001fc0, 0x00000000, // RAYGUI_ICON_UNDO_FILL
|
||||
0x00000000, 0x0c000400, 0x0c081ff8, 0x00080408, 0x00080008, 0x00080008, 0x000003f8, 0x00000000, // RAYGUI_ICON_REDO_FILL
|
||||
0x00000000, 0x3ffc0000, 0x20042004, 0x20002000, 0x20402000, 0x3ff02060, 0x00400060, 0x00000000, // RAYGUI_ICON_REREDO_FILL
|
||||
0x00000000, 0x3ffc0000, 0x20042004, 0x27fc2004, 0x20202000, 0x3ff82030, 0x00200030, 0x00000000, // RAYGUI_ICON_MUTATE_FILL
|
||||
0x00000000, 0x0ff00000, 0x10081818, 0x11801008, 0x10001180, 0x18301020, 0x00300ff8, 0x00000020, // RAYGUI_ICON_ROTATE_FILL
|
||||
0x00000000, 0x06000200, 0x26042ffc, 0x20042204, 0x20442004, 0x3ff42064, 0x00400060, 0x00000000, // RAYGUI_ICON_REPEAT_FILL
|
||||
0x00000000, 0x30001000, 0x32107c0e, 0x00801120, 0x11200040, 0x7c0e3210, 0x10003000, 0x00000000, // RAYGUI_ICON_SHUFFLE_FILL
|
||||
0x00000000, 0x30043ffc, 0x24042804, 0x21042204, 0x20442084, 0x20142024, 0x3ffc200c, 0x00000000, // RAYGUI_ICON_EMPTYBOX_SMALL
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX
|
||||
0x00000000, 0x23c43ffc, 0x23c423c4, 0x200423c4, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX_TOP
|
||||
0x00000000, 0x3e043ffc, 0x3e043e04, 0x20043e04, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX_TOP_RIGHT
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x3e043e04, 0x3e043e04, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX_RIGHT
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x3e042004, 0x3e043e04, 0x3ffc3e04, 0x00000000, // RAYGUI_ICON_BOX_BOTTOM_RIGHT
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x23c42004, 0x23c423c4, 0x3ffc23c4, 0x00000000, // RAYGUI_ICON_BOX_BOTTOM
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x20042004, 0x207c2004, 0x207c207c, 0x3ffc207c, 0x00000000, // RAYGUI_ICON_BOX_BOTTOM_LEFT
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x207c207c, 0x207c207c, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX_LEFT
|
||||
0x00000000, 0x207c3ffc, 0x207c207c, 0x2004207c, 0x20042004, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX_TOP_LEFT
|
||||
0x00000000, 0x20043ffc, 0x20042004, 0x23c423c4, 0x23c423c4, 0x20042004, 0x3ffc2004, 0x00000000, // RAYGUI_ICON_BOX_CENTER
|
||||
0x7ffe0000, 0x40024002, 0x47e24182, 0x4ff247e2, 0x47e24ff2, 0x418247e2, 0x40024002, 0x00007ffe, // RAYGUI_ICON_BOX_CIRCLE_MASK
|
||||
0x7fff0000, 0x40014001, 0x40014001, 0x49555ddd, 0x4945495d, 0x400149c5, 0x40014001, 0x00007fff, // RAYGUI_ICON_POT
|
||||
0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x404e40ce, 0x48125432, 0x4006540e, 0x00007ffe, // RAYGUI_ICON_ALPHA_MULTIPLY
|
||||
0x7ffe0000, 0x53327332, 0x44ce4cce, 0x41324332, 0x5c4e40ce, 0x44124432, 0x40065c0e, 0x00007ffe, // RAYGUI_ICON_ALPHA_CLEAR
|
||||
0x7ffe0000, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x42fe417e, 0x00007ffe, // RAYGUI_ICON_DITHERING
|
||||
0x07fe0000, 0x1ffa0002, 0x7fea000a, 0x402a402a, 0x5b2a512a, 0x5128552a, 0x40205128, 0x00007fe0, // RAYGUI_ICON_MIPMAPS
|
||||
0x00000000, 0x1ff80000, 0x12481248, 0x12481ff8, 0x1ff81248, 0x12481248, 0x00001ff8, 0x00000000, // RAYGUI_ICON_BOX_GRID
|
||||
0x12480000, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x7ffe1248, 0x12481248, 0x12487ffe, 0x00001248, // RAYGUI_ICON_GRID
|
||||
0x00000000, 0x1c380000, 0x1c3817e8, 0x08100810, 0x08100810, 0x17e81c38, 0x00001c38, 0x00000000, // RAYGUI_ICON_BOX_CORNERS_SMALL
|
||||
0x700e0000, 0x700e5ffa, 0x20042004, 0x20042004, 0x20042004, 0x20042004, 0x5ffa700e, 0x0000700e, // RAYGUI_ICON_BOX_CORNERS_BIG
|
||||
0x3f7e0000, 0x21422142, 0x21422142, 0x00003f7e, 0x21423f7e, 0x21422142, 0x3f7e2142, 0x00000000, // RAYGUI_ICON_FOUR_BOXES
|
||||
0x00000000, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x3bb80000, 0x3bb83bb8, 0x00000000, // RAYGUI_ICON_GRID_FILL
|
||||
0x7ffe0000, 0x7ffe7ffe, 0x77fe7000, 0x77fe77fe, 0x777e7700, 0x777e777e, 0x777e777e, 0x0000777e, // RAYGUI_ICON_BOX_MULTISIZE
|
||||
0x781e0000, 0x40024002, 0x00004002, 0x01800000, 0x00000180, 0x40020000, 0x40024002, 0x0000781e, // RAYGUI_ICON_ZOOM_SMALL
|
||||
0x781e0000, 0x40024002, 0x00004002, 0x03c003c0, 0x03c003c0, 0x40020000, 0x40024002, 0x0000781e, // RAYGUI_ICON_ZOOM_MEDIUM
|
||||
0x781e0000, 0x40024002, 0x07e04002, 0x07e007e0, 0x07e007e0, 0x400207e0, 0x40024002, 0x0000781e, // RAYGUI_ICON_ZOOM_BIG
|
||||
0x781e0000, 0x5ffa4002, 0x1ff85ffa, 0x1ff81ff8, 0x1ff81ff8, 0x5ffa1ff8, 0x40025ffa, 0x0000781e, // RAYGUI_ICON_ZOOM_ALL
|
||||
0x00000000, 0x2004381c, 0x00002004, 0x00000000, 0x00000000, 0x20040000, 0x381c2004, 0x00000000, // RAYGUI_ICON_ZOOM_CENTER
|
||||
0x00000000, 0x1db80000, 0x10081008, 0x10080000, 0x00001008, 0x10081008, 0x00001db8, 0x00000000, // RAYGUI_ICON_BOX_DOTS_SMALL
|
||||
0x35560000, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x00002002, 0x35562002, 0x00000000, // RAYGUI_ICON_BOX_DOTS_BIG
|
||||
0x7ffe0000, 0x40024002, 0x48124ff2, 0x49924812, 0x48124992, 0x4ff24812, 0x40024002, 0x00007ffe, // RAYGUI_ICON_BOX_CONCENTRIC
|
||||
0x00000000, 0x10841ffc, 0x10841084, 0x1ffc1084, 0x10841084, 0x10841084, 0x00001ffc, 0x00000000, // RAYGUI_ICON_BOX_GRID_BIG
|
||||
0x00000000, 0x00000000, 0x10000000, 0x04000800, 0x01040200, 0x00500088, 0x00000020, 0x00000000, // RAYGUI_ICON_OK_TICK
|
||||
0x00000000, 0x10080000, 0x04200810, 0x01800240, 0x02400180, 0x08100420, 0x00001008, 0x00000000, // RAYGUI_ICON_CROSS
|
||||
0x00000000, 0x02000000, 0x00800100, 0x00200040, 0x00200010, 0x00800040, 0x02000100, 0x00000000, // RAYGUI_ICON_ARROW_LEFT
|
||||
0x00000000, 0x00400000, 0x01000080, 0x04000200, 0x04000800, 0x01000200, 0x00400080, 0x00000000, // RAYGUI_ICON_ARROW_RIGHT
|
||||
0x00000000, 0x00000000, 0x00000000, 0x08081004, 0x02200410, 0x00800140, 0x00000000, 0x00000000, // RAYGUI_ICON_ARROW_BOTTOM
|
||||
0x00000000, 0x00000000, 0x01400080, 0x04100220, 0x10040808, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_ARROW_TOP
|
||||
0x00000000, 0x02000000, 0x03800300, 0x03e003c0, 0x03e003f0, 0x038003c0, 0x02000300, 0x00000000, // RAYGUI_ICON_ARROW_LEFT_FILL
|
||||
0x00000000, 0x00400000, 0x01c000c0, 0x07c003c0, 0x07c00fc0, 0x01c003c0, 0x004000c0, 0x00000000, // RAYGUI_ICON_ARROW_RIGHT_FILL
|
||||
0x00000000, 0x00000000, 0x00000000, 0x0ff81ffc, 0x03e007f0, 0x008001c0, 0x00000000, 0x00000000, // RAYGUI_ICON_ARROW_BOTTOM_FILL
|
||||
0x00000000, 0x00000000, 0x01c00080, 0x07f003e0, 0x1ffc0ff8, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_ARROW_TOP_FILL
|
||||
0x00000000, 0x18a008c0, 0x32881290, 0x24822686, 0x26862482, 0x12903288, 0x08c018a0, 0x00000000, // RAYGUI_ICON_AUDIO
|
||||
0x00000000, 0x04800780, 0x004000c0, 0x662000f0, 0x08103c30, 0x130a0e18, 0x0000318e, 0x00000000, // RAYGUI_ICON_FX
|
||||
0x00000000, 0x00800000, 0x08880888, 0x2aaa0a8a, 0x0a8a2aaa, 0x08880888, 0x00000080, 0x00000000, // RAYGUI_ICON_WAVE
|
||||
0x00000000, 0x00600000, 0x01080090, 0x02040108, 0x42044204, 0x24022402, 0x00001800, 0x00000000, // RAYGUI_ICON_WAVE_SINUS
|
||||
0x00000000, 0x07f80000, 0x04080408, 0x04080408, 0x04080408, 0x7c0e0408, 0x00000000, 0x00000000, // RAYGUI_ICON_WAVE_SQUARE
|
||||
0x00000000, 0x00000000, 0x00a00040, 0x22084110, 0x08021404, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_WAVE_TRIANGULAR
|
||||
0x00000000, 0x00000000, 0x04200000, 0x01800240, 0x02400180, 0x00000420, 0x00000000, 0x00000000, // RAYGUI_ICON_CROSS_SMALL
|
||||
0x00000000, 0x18380000, 0x12281428, 0x10a81128, 0x112810a8, 0x14281228, 0x00001838, 0x00000000, // RAYGUI_ICON_PLAYER_PREVIOUS
|
||||
0x00000000, 0x18000000, 0x11801600, 0x10181060, 0x10601018, 0x16001180, 0x00001800, 0x00000000, // RAYGUI_ICON_PLAYER_PLAY_BACK
|
||||
0x00000000, 0x00180000, 0x01880068, 0x18080608, 0x06081808, 0x00680188, 0x00000018, 0x00000000, // RAYGUI_ICON_PLAYER_PLAY
|
||||
0x00000000, 0x1e780000, 0x12481248, 0x12481248, 0x12481248, 0x12481248, 0x00001e78, 0x00000000, // RAYGUI_ICON_PLAYER_PAUSE
|
||||
0x00000000, 0x1ff80000, 0x10081008, 0x10081008, 0x10081008, 0x10081008, 0x00001ff8, 0x00000000, // RAYGUI_ICON_PLAYER_STOP
|
||||
0x00000000, 0x1c180000, 0x14481428, 0x15081488, 0x14881508, 0x14281448, 0x00001c18, 0x00000000, // RAYGUI_ICON_PLAYER_NEXT
|
||||
0x00000000, 0x03c00000, 0x08100420, 0x10081008, 0x10081008, 0x04200810, 0x000003c0, 0x00000000, // RAYGUI_ICON_PLAYER_RECORD
|
||||
0x00000000, 0x0c3007e0, 0x13c81818, 0x14281668, 0x14281428, 0x1c381c38, 0x08102244, 0x00000000, // RAYGUI_ICON_MAGNET
|
||||
0x07c00000, 0x08200820, 0x3ff80820, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // RAYGUI_ICON_LOCK_CLOSE
|
||||
0x07c00000, 0x08000800, 0x3ff80800, 0x23882008, 0x21082388, 0x20082108, 0x1ff02008, 0x00000000, // RAYGUI_ICON_LOCK_OPEN
|
||||
0x01c00000, 0x0c180770, 0x3086188c, 0x60832082, 0x60034781, 0x30062002, 0x0c18180c, 0x01c00770, // RAYGUI_ICON_CLOCK
|
||||
0x0a200000, 0x1b201b20, 0x04200e20, 0x04200420, 0x04700420, 0x0e700e70, 0x0e700e70, 0x04200e70, // RAYGUI_ICON_TOOLS
|
||||
0x01800000, 0x3bdc318c, 0x0ff01ff8, 0x7c3e1e78, 0x1e787c3e, 0x1ff80ff0, 0x318c3bdc, 0x00000180, // RAYGUI_ICON_GEAR
|
||||
0x01800000, 0x3ffc318c, 0x1c381ff8, 0x781e1818, 0x1818781e, 0x1ff81c38, 0x318c3ffc, 0x00000180, // RAYGUI_ICON_GEAR_BIG
|
||||
0x00000000, 0x08080ff8, 0x08081ffc, 0x0aa80aa8, 0x0aa80aa8, 0x0aa80aa8, 0x08080aa8, 0x00000ff8, // RAYGUI_ICON_BIN
|
||||
0x00000000, 0x00000000, 0x20043ffc, 0x08043f84, 0x04040f84, 0x04040784, 0x000007fc, 0x00000000, // RAYGUI_ICON_HAND_POINTER
|
||||
0x00000000, 0x24400400, 0x00001480, 0x6efe0e00, 0x00000e00, 0x24401480, 0x00000400, 0x00000000, // RAYGUI_ICON_LASER
|
||||
0x00000000, 0x03c00000, 0x08300460, 0x11181118, 0x11181118, 0x04600830, 0x000003c0, 0x00000000, // RAYGUI_ICON_COIN
|
||||
0x00000000, 0x10880080, 0x06c00810, 0x366c07e0, 0x07e00240, 0x00001768, 0x04200240, 0x00000000, // RAYGUI_ICON_EXPLOSION
|
||||
0x00000000, 0x3d280000, 0x2528252c, 0x3d282528, 0x05280528, 0x05e80528, 0x00000000, 0x00000000, // RAYGUI_ICON_1UP
|
||||
0x01800000, 0x03c003c0, 0x018003c0, 0x0ff007e0, 0x0bd00bd0, 0x0a500bd0, 0x02400240, 0x02400240, // RAYGUI_ICON_PLAYER
|
||||
0x01800000, 0x03c003c0, 0x118013c0, 0x03c81ff8, 0x07c003c8, 0x04400440, 0x0c080478, 0x00000000, // RAYGUI_ICON_PLAYER_JUMP
|
||||
0x3ff80000, 0x30183ff8, 0x30183018, 0x3ff83ff8, 0x03000300, 0x03c003c0, 0x03e00300, 0x000003e0, // RAYGUI_ICON_KEY
|
||||
0x3ff80000, 0x3ff83ff8, 0x33983ff8, 0x3ff83398, 0x3ff83ff8, 0x00000540, 0x0fe00aa0, 0x00000fe0, // RAYGUI_ICON_DEMON
|
||||
0x00000000, 0x0ff00000, 0x20041008, 0x25442004, 0x10082004, 0x06000bf0, 0x00000300, 0x00000000, // RAYGUI_ICON_TEXT_POPUP
|
||||
0x00000000, 0x11440000, 0x07f00be8, 0x1c1c0e38, 0x1c1c0c18, 0x07f00e38, 0x11440be8, 0x00000000, // RAYGUI_ICON_GEAR_EX
|
||||
0x00000000, 0x20080000, 0x0c601010, 0x07c00fe0, 0x07c007c0, 0x0c600fe0, 0x20081010, 0x00000000, // RAYGUI_ICON_CRACK
|
||||
0x00000000, 0x20080000, 0x0c601010, 0x04400fe0, 0x04405554, 0x0c600fe0, 0x20081010, 0x00000000, // RAYGUI_ICON_CRACK_POINTS
|
||||
0x00000000, 0x00800080, 0x01c001c0, 0x1ffc3ffe, 0x03e007f0, 0x07f003e0, 0x0c180770, 0x00000808, // RAYGUI_ICON_STAR
|
||||
0x0ff00000, 0x08180810, 0x08100818, 0x0a100810, 0x08180810, 0x08100818, 0x08100810, 0x00001ff8, // RAYGUI_ICON_DOOR
|
||||
0x0ff00000, 0x08100810, 0x08100810, 0x10100010, 0x4f902010, 0x10102010, 0x08100010, 0x00000ff0, // RAYGUI_ICON_EXIT
|
||||
0x00040000, 0x001f000e, 0x0ef40004, 0x12f41284, 0x0ef41214, 0x10040004, 0x7ffc3004, 0x10003000, // RAYGUI_ICON_MODE_2D
|
||||
0x78040000, 0x501f600e, 0x0ef44004, 0x12f41284, 0x0ef41284, 0x10140004, 0x7ffc300c, 0x10003000, // RAYGUI_ICON_MODE_3D
|
||||
0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // RAYGUI_ICON_CUBE
|
||||
0x7fe00000, 0x5ff87ff0, 0x47fe4ffc, 0x44224402, 0x44224422, 0x241275e2, 0x0c06140a, 0x000007fe, // RAYGUI_ICON_CUBE_FACE_TOP
|
||||
0x7fe00000, 0x50386030, 0x47fe483c, 0x443e443e, 0x443e443e, 0x241e75fe, 0x0c06140e, 0x000007fe, // RAYGUI_ICON_CUBE_FACE_LEFT
|
||||
0x7fe00000, 0x50286030, 0x47fe4804, 0x47fe47fe, 0x47fe47fe, 0x27fe77fe, 0x0ffe17fe, 0x000007fe, // RAYGUI_ICON_CUBE_FACE_FRONT
|
||||
0x7fe00000, 0x50286030, 0x47fe4804, 0x44224402, 0x44224422, 0x3ff27fe2, 0x0ffe1ffa, 0x000007fe, // RAYGUI_ICON_CUBE_FACE_BOTTOM
|
||||
0x7fe00000, 0x70286030, 0x7ffe7804, 0x7c227c02, 0x7c227c22, 0x3c127de2, 0x0c061c0a, 0x000007fe, // RAYGUI_ICON_CUBE_FACE_RIGHT
|
||||
0x7fe00000, 0x7fe87ff0, 0x7ffe7fe4, 0x7fe27fe2, 0x7fe27fe2, 0x24127fe2, 0x0c06140a, 0x000007fe, // RAYGUI_ICON_CUBE_FACE_BACK
|
||||
0x00000000, 0x2a0233fe, 0x22022602, 0x22022202, 0x2a022602, 0x00a033fe, 0x02080110, 0x00000000, // RAYGUI_ICON_CAMERA
|
||||
0x00000000, 0x200c3ffc, 0x000c000c, 0x3ffc000c, 0x30003000, 0x30003000, 0x3ffc3004, 0x00000000, // RAYGUI_ICON_SPECIAL
|
||||
0x00000000, 0x0022003e, 0x012201e2, 0x0100013e, 0x01000100, 0x79000100, 0x4f004900, 0x00007800, // RAYGUI_ICON_LINK_NET
|
||||
0x00000000, 0x44007c00, 0x45004600, 0x00627cbe, 0x00620022, 0x45007cbe, 0x44004600, 0x00007c00, // RAYGUI_ICON_LINK_BOXES
|
||||
0x00000000, 0x0044007c, 0x0010007c, 0x3f100010, 0x3f1021f0, 0x3f100010, 0x3f0021f0, 0x00000000, // RAYGUI_ICON_LINK_MULTI
|
||||
0x00000000, 0x0044007c, 0x00440044, 0x0010007c, 0x00100010, 0x44107c10, 0x440047f0, 0x00007c00, // RAYGUI_ICON_LINK
|
||||
0x00000000, 0x0044007c, 0x00440044, 0x0000007c, 0x00000010, 0x44007c10, 0x44004550, 0x00007c00, // RAYGUI_ICON_LINK_BROKE
|
||||
0x02a00000, 0x22a43ffc, 0x20042004, 0x20042ff4, 0x20042ff4, 0x20042ff4, 0x20042004, 0x00003ffc, // RAYGUI_ICON_TEXT_NOTES
|
||||
0x3ffc0000, 0x20042004, 0x245e27c4, 0x27c42444, 0x2004201e, 0x201e2004, 0x20042004, 0x00003ffc, // RAYGUI_ICON_NOTEBOOK
|
||||
0x00000000, 0x07e00000, 0x04200420, 0x24243ffc, 0x24242424, 0x24242424, 0x3ffc2424, 0x00000000, // RAYGUI_ICON_SUITCASE
|
||||
0x00000000, 0x0fe00000, 0x08200820, 0x40047ffc, 0x7ffc5554, 0x40045554, 0x7ffc4004, 0x00000000, // RAYGUI_ICON_SUITCASE_ZIP
|
||||
0x00000000, 0x20043ffc, 0x3ffc2004, 0x13c81008, 0x100813c8, 0x10081008, 0x1ff81008, 0x00000000, // RAYGUI_ICON_MAILBOX
|
||||
0x00000000, 0x40027ffe, 0x5ffa5ffa, 0x5ffa5ffa, 0x40025ffa, 0x03c07ffe, 0x1ff81ff8, 0x00000000, // RAYGUI_ICON_MONITOR
|
||||
0x0ff00000, 0x6bfe7ffe, 0x7ffe7ffe, 0x68167ffe, 0x08106816, 0x08100810, 0x0ff00810, 0x00000000, // RAYGUI_ICON_PRINTER
|
||||
0x3ff80000, 0xfffe2008, 0x870a8002, 0x904a888a, 0x904a904a, 0x870a888a, 0xfffe8002, 0x00000000, // RAYGUI_ICON_PHOTO_CAMERA
|
||||
0x0fc00000, 0xfcfe0cd8, 0x8002fffe, 0x84428382, 0x84428442, 0x80028382, 0xfffe8002, 0x00000000, // RAYGUI_ICON_PHOTO_CAMERA_FLASH
|
||||
0x00000000, 0x02400180, 0x08100420, 0x20041008, 0x23c42004, 0x22442244, 0x3ffc2244, 0x00000000, // RAYGUI_ICON_HOUSE
|
||||
0x00000000, 0x1c700000, 0x3ff83ef8, 0x3ff83ff8, 0x0fe01ff0, 0x038007c0, 0x00000100, 0x00000000, // RAYGUI_ICON_HEART
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x80000000, 0xe000c000, // RAYGUI_ICON_CORNER
|
||||
0x00000000, 0x14001c00, 0x15c01400, 0x15401540, 0x155c1540, 0x15541554, 0x1ddc1554, 0x00000000, // RAYGUI_ICON_VERTICAL_BARS
|
||||
0x00000000, 0x03000300, 0x1b001b00, 0x1b601b60, 0x1b6c1b60, 0x1b6c1b6c, 0x1b6c1b6c, 0x00000000, // RAYGUI_ICON_VERTICAL_BARS_FILL
|
||||
0x00000000, 0x00000000, 0x403e7ffe, 0x7ffe403e, 0x7ffe0000, 0x43fe43fe, 0x00007ffe, 0x00000000, // RAYGUI_ICON_LIFE_BARS
|
||||
0x7ffc0000, 0x43844004, 0x43844284, 0x43844004, 0x42844284, 0x42844284, 0x40044384, 0x00007ffc, // RAYGUI_ICON_INFO
|
||||
0x40008000, 0x10002000, 0x04000800, 0x01000200, 0x00400080, 0x00100020, 0x00040008, 0x00010002, // RAYGUI_ICON_CROSSLINE
|
||||
0x00000000, 0x1ff01ff0, 0x18301830, 0x1f001830, 0x03001f00, 0x00000300, 0x03000300, 0x00000000, // RAYGUI_ICON_HELP
|
||||
0x3ff00000, 0x2abc3550, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x2aac3554, 0x00003ffc, // RAYGUI_ICON_FILETYPE_ALPHA
|
||||
0x3ff00000, 0x201c2010, 0x22442184, 0x28142424, 0x29942814, 0x2ff42994, 0x20042004, 0x00003ffc, // RAYGUI_ICON_FILETYPE_HOME
|
||||
0x07fe0000, 0x04020402, 0x7fe20402, 0x44224422, 0x44224422, 0x402047fe, 0x40204020, 0x00007fe0, // RAYGUI_ICON_LAYERS_VISIBLE
|
||||
0x07fe0000, 0x04020402, 0x7c020402, 0x44024402, 0x44024402, 0x402047fe, 0x40204020, 0x00007fe0, // RAYGUI_ICON_LAYERS
|
||||
0x00000000, 0x40027ffe, 0x7ffe4002, 0x40024002, 0x40024002, 0x40024002, 0x7ffe4002, 0x00000000, // RAYGUI_ICON_WINDOW
|
||||
0x09100000, 0x09f00910, 0x09100910, 0x00000910, 0x24a2779e, 0x27a224a2, 0x709e20a2, 0x00000000, // RAYGUI_ICON_199
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_200
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_201
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_202
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_203
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_204
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_205
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_206
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_207
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_208
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_209
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_210
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_211
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_212
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_213
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_214
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_215
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_216
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_217
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_218
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_219
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_220
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_221
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_222
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_223
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_224
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_225
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_226
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_227
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_228
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_229
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_230
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_231
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_232
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_233
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_234
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_235
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_236
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_237
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_238
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_239
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_240
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_241
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_242
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_243
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_244
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_245
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_246
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_247
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_248
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_249
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_250
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_251
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_252
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_253
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_254
|
||||
0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, // RAYGUI_ICON_255
|
||||
};
|
||||
5
libs/raylib/inject.c
Normal file
5
libs/raylib/inject.c
Normal file
@ -0,0 +1,5 @@
|
||||
#define GRAPHICS_API_OPENGL_11
|
||||
// #define RLGL_IMPLEMENTATION
|
||||
#include "raylib.h"
|
||||
#include "rlgl.h"
|
||||
#include "raymath.h"
|
||||
12
libs/raylib/inject.h
Normal file
12
libs/raylib/inject.h
Normal file
@ -0,0 +1,12 @@
|
||||
//--- CORE ----------------------------------------------------------------------------------------
|
||||
#define GRAPHICS_API_OPENGL_11
|
||||
// #define RLGL_IMPLEMENTATION
|
||||
#include "raylib.h"
|
||||
#include "rlgl.h"
|
||||
#include "raymath.h"
|
||||
|
||||
// Enable vertex state pointer
|
||||
void rlEnableStatePointer(int vertexAttribType, void *buffer);
|
||||
|
||||
// Disable vertex state pointer
|
||||
void rlDisableStatePointer(int vertexAttribType);
|
||||
999
libs/raylib/inject.zig
Normal file
999
libs/raylib/inject.zig
Normal file
@ -0,0 +1,999 @@
|
||||
const std = @import("std");
|
||||
const raylib = @cImport({
|
||||
@cInclude("raylib.h");
|
||||
|
||||
@cDefine("GRAPHICS_API_OPENGL_11", {});
|
||||
// @cDefine("RLGL_IMPLEMENTATION", {});
|
||||
@cInclude("rlgl.h");
|
||||
|
||||
@cDefine("RAYMATH_IMPLEMENTATION", {});
|
||||
@cInclude("raymath.h");
|
||||
|
||||
@cInclude("marshal.h");
|
||||
});
|
||||
|
||||
//--- structs -------------------------------------------------------------------------------------
|
||||
|
||||
/// System/Window config flags
|
||||
pub const ConfigFlags = packed struct(u32) {
|
||||
FLAG_UNKNOWN_1: bool = false, // 0x0001
|
||||
/// Set to run program in fullscreen
|
||||
FLAG_FULLSCREEN_MODE: bool = false, // 0x0002,
|
||||
/// Set to allow resizable window
|
||||
FLAG_WINDOW_RESIZABLE: bool = false, // 0x0004,
|
||||
/// Set to disable window decoration (frame and buttons)
|
||||
FLAG_WINDOW_UNDECORATED: bool = false, // 0x0008,
|
||||
/// Set to allow transparent framebuffer
|
||||
FLAG_WINDOW_TRANSPARENT: bool = false, // 0x0010,
|
||||
/// Set to try enabling MSAA 4X
|
||||
FLAG_MSAA_4X_HINT: bool = false, // 0x0020,
|
||||
/// Set to try enabling V-Sync on GPU
|
||||
FLAG_VSYNC_HINT: bool = false, // 0x0040,
|
||||
/// Set to hide window
|
||||
FLAG_WINDOW_HIDDEN: bool = false, // 0x0080,
|
||||
/// Set to allow windows running while minimized
|
||||
FLAG_WINDOW_ALWAYS_RUN: bool = false, // 0x0100,
|
||||
/// Set to minimize window (iconify)
|
||||
FLAG_WINDOW_MINIMIZED: bool = false, // 0x0200,
|
||||
/// Set to maximize window (expanded to monitor)
|
||||
FLAG_WINDOW_MAXIMIZED: bool = false, // 0x0400,
|
||||
/// Set to window non focused
|
||||
FLAG_WINDOW_UNFOCUSED: bool = false, // 0x0800,
|
||||
/// Set to window always on top
|
||||
FLAG_WINDOW_TOPMOST: bool = false, // 0x1000,
|
||||
/// Set to support HighDPI
|
||||
FLAG_WINDOW_HIGHDPI: bool = false, // 0x2000,
|
||||
/// Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED
|
||||
FLAG_WINDOW_MOUSE_PASSTHROUGH: bool = false, // 0x4000,
|
||||
FLAG_UNKNOWN_2: bool = false, // 0x8000
|
||||
/// Set to try enabling interlaced video format (for V3D)
|
||||
FLAG_INTERLACED_HINT: bool = false, // 0x10000
|
||||
FLAG_PADDING: u15 = 0, // 0xFFFE0000
|
||||
};
|
||||
|
||||
/// Transform, vectex transformation data
|
||||
pub const Transform = extern struct {
|
||||
/// Translation
|
||||
translation: Vector3,
|
||||
/// Rotation
|
||||
rotation: Vector4,
|
||||
/// Scale
|
||||
scale: Vector3,
|
||||
};
|
||||
|
||||
/// Matrix, 4x4 components, column major, OpenGL style, right handed
|
||||
pub const Matrix = extern struct {
|
||||
/// Matrix first row (4 components) [m0, m4, m8, m12]
|
||||
m0: f32,
|
||||
m4: f32,
|
||||
m8: f32,
|
||||
m12: f32,
|
||||
/// Matrix second row (4 components) [m1, m5, m9, m13]
|
||||
m1: f32,
|
||||
m5: f32,
|
||||
m9: f32,
|
||||
m13: f32,
|
||||
/// Matrix third row (4 components) [m2, m6, m10, m14]
|
||||
m2: f32,
|
||||
m6: f32,
|
||||
m10: f32,
|
||||
m14: f32,
|
||||
/// Matrix fourth row (4 components) [m3, m7, m11, m15]
|
||||
m3: f32,
|
||||
m7: f32,
|
||||
m11: f32,
|
||||
m15: f32,
|
||||
|
||||
pub fn zero() @This() {
|
||||
return @This(){
|
||||
.m0 = 0,
|
||||
.m1 = 0,
|
||||
.m2 = 0,
|
||||
.m3 = 0,
|
||||
.m4 = 0,
|
||||
.m5 = 0,
|
||||
.m6 = 0,
|
||||
.m7 = 0,
|
||||
.m8 = 0,
|
||||
.m9 = 0,
|
||||
.m10 = 0,
|
||||
.m11 = 0,
|
||||
.m12 = 0,
|
||||
.m13 = 0,
|
||||
.m14 = 0,
|
||||
.m15 = 0,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn identity() @This() {
|
||||
return MatrixIdentity();
|
||||
}
|
||||
};
|
||||
|
||||
pub const Rectangle = extern struct {
|
||||
x: f32 = 0,
|
||||
y: f32 = 0,
|
||||
width: f32 = 0,
|
||||
height: f32 = 0,
|
||||
|
||||
pub fn toI32(self: @This()) RectangleI {
|
||||
return .{
|
||||
.x = @as(i32, @intFromFloat(self.x)),
|
||||
.y = @as(i32, @intFromFloat(self.y)),
|
||||
.width = @as(i32, @intFromFloat(self.width)),
|
||||
.height = @as(i32, @intFromFloat(self.height)),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn pos(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x,
|
||||
.y = self.y,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn size(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.width,
|
||||
.y = self.height,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn topLeft(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x,
|
||||
.y = self.y,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn topCenter(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + self.width / 2,
|
||||
.y = self.y,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn topRight(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + self.width,
|
||||
.y = self.y,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn centerLeft(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x,
|
||||
.y = self.y + self.height / 2,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn center(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + self.width / 2,
|
||||
.y = self.y + self.height / 2,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn centerRight(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + self.width,
|
||||
.y = self.y + self.height / 2,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn bottomLeft(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + 0,
|
||||
.y = self.y + self.height,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn bottomCenter(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + self.width / 2,
|
||||
.y = self.y + self.height,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn bottomRight(self: @This()) Vector2 {
|
||||
return .{
|
||||
.x = self.x + self.width,
|
||||
.y = self.y + self.height,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn area(self: @This()) f32 {
|
||||
return self.width * self.height;
|
||||
}
|
||||
|
||||
pub fn include(self: @This(), other: @This()) @This() {
|
||||
return self.includePoint(other.topLeft()).includePoint(other.bottomRight());
|
||||
}
|
||||
|
||||
pub fn includePoint(self: @This(), point: Vector2) @This() {
|
||||
const minX = @min(self.x, point.x);
|
||||
const minY = @min(self.y, point.y);
|
||||
const maxX = @max(self.x + self.width, point.x);
|
||||
const maxY = @max(self.y + self.height, point.y);
|
||||
|
||||
return .{
|
||||
.x = minX,
|
||||
.y = minY,
|
||||
.width = maxX - minX,
|
||||
.height = maxY - minY,
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
pub const RectangleI = extern struct {
|
||||
x: i32 = 0,
|
||||
y: i32 = 0,
|
||||
width: i32 = 0,
|
||||
height: i32 = 0,
|
||||
|
||||
pub fn toF32(self: @This()) Rectangle {
|
||||
return .{
|
||||
.x = @as(f32, @floatFromInt(self.x)),
|
||||
.y = @as(f32, @floatFromInt(self.y)),
|
||||
.width = @as(f32, @floatFromInt(self.width)),
|
||||
.height = @as(f32, @floatFromInt(self.height)),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn pos(self: @This()) Vector2i {
|
||||
return .{
|
||||
.x = self.x,
|
||||
.y = self.y,
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
pub const Vector2 = extern struct {
|
||||
x: f32 = 0,
|
||||
y: f32 = 0,
|
||||
|
||||
pub fn zero() @This() {
|
||||
return .{ .x = 0, .y = 0 };
|
||||
}
|
||||
|
||||
pub fn setZero(self: *@This()) void {
|
||||
self.x = 0;
|
||||
self.y = 0;
|
||||
}
|
||||
|
||||
pub fn one() @This() {
|
||||
return @This(){ .x = 1, .y = 1 };
|
||||
}
|
||||
|
||||
pub fn neg(self: @This()) @This() {
|
||||
return @This(){ .x = -self.x, .y = -self.y };
|
||||
}
|
||||
|
||||
pub fn length2(self: @This()) f32 {
|
||||
var sum = self.x * self.x;
|
||||
sum += self.y * self.y;
|
||||
return sum;
|
||||
}
|
||||
|
||||
pub fn length(self: @This()) f32 {
|
||||
return std.math.sqrt(self.length2());
|
||||
}
|
||||
|
||||
pub fn distanceTo(self: @This(), other: @This()) f32 {
|
||||
return self.sub(other).length();
|
||||
}
|
||||
|
||||
pub fn distanceToSquared(self: @This(), other: @This()) f32 {
|
||||
return self.sub(other).length2();
|
||||
}
|
||||
|
||||
pub fn normalize(self: @This()) @This() {
|
||||
const l = self.length();
|
||||
if (l == 0.0) return @This().zero();
|
||||
return self.scale(1.0 / l);
|
||||
}
|
||||
|
||||
pub fn scale(self: @This(), factor: f32) @This() {
|
||||
return @This(){
|
||||
.x = self.x * factor,
|
||||
.y = self.y * factor,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn add(self: @This(), other: @This()) @This() {
|
||||
return @This(){
|
||||
.x = self.x + other.x,
|
||||
.y = self.y + other.y,
|
||||
};
|
||||
}
|
||||
|
||||
/// same as add but assign result directly to this
|
||||
pub fn addSet(self: *@This(), other: @This()) void {
|
||||
self.x += other.x;
|
||||
self.y += other.y;
|
||||
}
|
||||
|
||||
pub fn sub(self: @This(), other: @This()) @This() {
|
||||
return @This(){
|
||||
.x = self.x - other.x,
|
||||
.y = self.y - other.y,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
||||
return self.scale(1 - t).add(other.scale(t));
|
||||
}
|
||||
|
||||
pub fn randomInUnitCircle(rng: std.rand.Random) @This() {
|
||||
return randomOnUnitCircle(rng).scale(randomF32(rng, 0, 1));
|
||||
}
|
||||
|
||||
pub fn randomOnUnitCircle(rng: std.rand.Random) @This() {
|
||||
return (Vector2{ .x = 1 }).rotate(randomF32(rng, -PI, PI));
|
||||
}
|
||||
|
||||
pub fn clampX(self: @This(), minX: f32, maxX: f32) @This() {
|
||||
return .{
|
||||
.x = std.math.clamp(self.x, minX, maxX),
|
||||
.y = self.y,
|
||||
};
|
||||
}
|
||||
pub fn clampY(self: @This(), minY: f32, maxY: f32) @This() {
|
||||
return .{
|
||||
.x = self.x,
|
||||
.y = std.math.clamp(self.y, minY, maxY),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn int(self: @This()) Vector2i {
|
||||
return .{ .x = @as(i32, @intFromFloat(self.x)), .y = @as(i32, @intFromFloat(self.y)) };
|
||||
}
|
||||
|
||||
/// Cross product
|
||||
pub fn cross(self: @This(), other: @This()) f32 {
|
||||
return self.x * other.y - self.y * other.x;
|
||||
}
|
||||
|
||||
/// Dot product.
|
||||
pub fn dot(self: @This(), other: @This()) f32 {
|
||||
return self.x * other.x + self.y * other.y;
|
||||
}
|
||||
|
||||
pub fn rotate(self: @This(), a: f32) @This() {
|
||||
return Vector2Rotate(self, a);
|
||||
}
|
||||
|
||||
pub fn fromAngle(a: f32) @This() {
|
||||
return Vector2Rotate(.{ .x = 1 }, a);
|
||||
}
|
||||
|
||||
pub fn angle(this: @This()) f32 {
|
||||
const zeroRotation: Vector2 = .{ .x = 1, .y = 0 };
|
||||
if (this.x == zeroRotation.x and this.y == zeroRotation.y) return 0;
|
||||
|
||||
const c = zeroRotation.cross(this);
|
||||
const d = zeroRotation.dot(this);
|
||||
return std.math.atan2(f32, c, d);
|
||||
}
|
||||
|
||||
pub fn xy0(self: @This()) Vector3 {
|
||||
return .{ .x = self.x, .y = self.y };
|
||||
}
|
||||
|
||||
pub fn x0z(self: @This()) Vector3 {
|
||||
return .{ .x = self.x, .z = self.y };
|
||||
}
|
||||
|
||||
pub fn set(self: @This(), setter: struct { x: ?f32 = null, y: ?f32 = null }) Vector2 {
|
||||
var copy = self;
|
||||
if (setter.x) |x| copy.x = x;
|
||||
if (setter.y) |y| copy.y = y;
|
||||
return copy;
|
||||
}
|
||||
};
|
||||
|
||||
pub const Vector2i = extern struct {
|
||||
x: i32 = 0,
|
||||
y: i32 = 0,
|
||||
|
||||
pub fn float(self: @This()) Vector2 {
|
||||
return .{ .x = @as(f32, @floatFromInt(self.x)), .y = @as(f32, @floatFromInt(self.y)) };
|
||||
}
|
||||
};
|
||||
|
||||
pub const Vector3 = extern struct {
|
||||
x: f32 = 0,
|
||||
y: f32 = 0,
|
||||
z: f32 = 0,
|
||||
|
||||
pub fn new(x: f32, y: f32, z: f32) @This() {
|
||||
return @This(){ .x = x, .y = y, .z = z };
|
||||
}
|
||||
|
||||
pub fn zero() @This() {
|
||||
return @This(){ .x = 0, .y = 0, .z = 0 };
|
||||
}
|
||||
|
||||
pub fn one() @This() {
|
||||
return @This(){ .x = 1, .y = 1, .z = 1 };
|
||||
}
|
||||
|
||||
pub fn length2(self: @This()) f32 {
|
||||
var sum = self.x * self.x;
|
||||
sum += self.y * self.y;
|
||||
sum += self.z * self.z;
|
||||
return sum;
|
||||
}
|
||||
|
||||
pub fn length(self: @This()) f32 {
|
||||
return std.math.sqrt(self.length2());
|
||||
}
|
||||
|
||||
pub fn normalize(self: @This()) @This() {
|
||||
const l = self.length();
|
||||
if (l == 0.0) return @This().zero();
|
||||
return self.scale(1.0 / l);
|
||||
}
|
||||
|
||||
pub fn scale(self: @This(), factor: f32) @This() {
|
||||
return @This(){
|
||||
.x = self.x * factor,
|
||||
.y = self.y * factor,
|
||||
.z = self.z * factor,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn add(self: @This(), other: @This()) @This() {
|
||||
return @This(){
|
||||
.x = self.x + other.x,
|
||||
.y = self.y + other.y,
|
||||
.z = self.z + other.z,
|
||||
};
|
||||
}
|
||||
pub fn sub(self: @This(), other: @This()) @This() {
|
||||
return @This(){
|
||||
.x = self.x - other.x,
|
||||
.y = self.y - other.y,
|
||||
.z = self.z - other.z,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn neg(this: @This()) @This() {
|
||||
return .{
|
||||
.x = -this.x,
|
||||
.y = -this.y,
|
||||
.z = -this.z,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
||||
return self.scale(1 - t).add(other.scale(t));
|
||||
}
|
||||
|
||||
pub fn forward() @This() {
|
||||
return @This().new(0, 0, 1);
|
||||
}
|
||||
|
||||
pub fn rotate(self: @This(), quaternion: Vector4) @This() {
|
||||
return Vector3RotateByQuaternion(self, quaternion);
|
||||
}
|
||||
|
||||
pub fn angleBetween(self: @This(), other: Vector3) f32 {
|
||||
return Vector3Angle(self, other);
|
||||
// return std.math.acos(self.dot(other) / (self.length() * other.length()));
|
||||
}
|
||||
|
||||
/// Dot product.
|
||||
pub fn dot(self: @This(), other: @This()) f32 {
|
||||
return self.x * other.x + self.y * other.y + self.z * other.z;
|
||||
}
|
||||
|
||||
pub fn xy(self: @This()) Vector2 {
|
||||
return .{ .x = self.x, .y = self.y };
|
||||
}
|
||||
|
||||
pub fn set(self: @This(), setter: struct { x: ?f32 = null, y: ?f32 = null, z: ?f32 = null }) Vector3 {
|
||||
var copy = self;
|
||||
if (setter.x) |x| copy.x = x;
|
||||
if (setter.y) |y| copy.y = y;
|
||||
if (setter.z) |z| copy.z = z;
|
||||
return copy;
|
||||
}
|
||||
};
|
||||
|
||||
pub const Vector4 = extern struct {
|
||||
x: f32 = 0,
|
||||
y: f32 = 0,
|
||||
z: f32 = 0,
|
||||
w: f32 = 0,
|
||||
|
||||
pub fn zero() @This() {
|
||||
return @This(){ .x = 0, .y = 0, .z = 0 };
|
||||
}
|
||||
|
||||
pub fn one() @This() {
|
||||
return @This(){ .x = 1, .y = 1, .z = 1 };
|
||||
}
|
||||
|
||||
pub fn length2(self: @This()) f32 {
|
||||
var sum = self.x * self.x;
|
||||
sum += self.y * self.y;
|
||||
sum += self.z * self.z;
|
||||
sum += self.w * self.w;
|
||||
return sum;
|
||||
}
|
||||
|
||||
pub fn length(self: @This()) f32 {
|
||||
return std.math.sqrt(self.length2());
|
||||
}
|
||||
|
||||
pub fn normalize(self: @This()) @This() {
|
||||
const l = self.length();
|
||||
if (l == 0.0) return @This().zero();
|
||||
return self.scale(1.0 / l);
|
||||
}
|
||||
|
||||
pub fn scale(self: @This(), factor: f32) @This() {
|
||||
return @This(){
|
||||
.x = self.x * factor,
|
||||
.y = self.y * factor,
|
||||
.z = self.z * factor,
|
||||
.w = self.w * factor,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn add(self: @This(), other: @This()) @This() {
|
||||
return @This(){
|
||||
.x = self.x + other.x,
|
||||
.y = self.y + other.y,
|
||||
.z = self.z + other.z,
|
||||
.w = self.w + other.w,
|
||||
};
|
||||
}
|
||||
pub fn sub(self: @This(), other: @This()) @This() {
|
||||
return @This(){
|
||||
.x = self.x - other.x,
|
||||
.y = self.y - other.y,
|
||||
.z = self.z - other.z,
|
||||
.w = self.w - other.w,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
||||
return self.scale(1 - t).add(other.scale(t));
|
||||
}
|
||||
|
||||
pub fn toColor(self: @This()) Color {
|
||||
return .{
|
||||
.r = @as(u8, @intFromFloat(std.math.clamp(self.x * 255, 0, 255))),
|
||||
.g = @as(u8, @intFromFloat(std.math.clamp(self.y * 255, 0, 255))),
|
||||
.b = @as(u8, @intFromFloat(std.math.clamp(self.z * 255, 0, 255))),
|
||||
.a = @as(u8, @intFromFloat(std.math.clamp(self.w * 255, 0, 255))),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn fromAngleAxis(axis: Vector3, angle: f32) @This() {
|
||||
return QuaternionFromAxisAngle(axis, angle);
|
||||
}
|
||||
};
|
||||
|
||||
/// Color type, RGBA (32bit)
|
||||
pub const Color = extern struct {
|
||||
r: u8 = 0,
|
||||
g: u8 = 0,
|
||||
b: u8 = 0,
|
||||
a: u8 = 255,
|
||||
|
||||
pub const ColorChangeConfig = struct {
|
||||
r: ?u8 = null,
|
||||
g: ?u8 = null,
|
||||
b: ?u8 = null,
|
||||
a: ?u8 = null,
|
||||
};
|
||||
|
||||
pub fn set(self: @This(), c: ColorChangeConfig) Color {
|
||||
return .{
|
||||
.r = if (c.r) |_r| _r else self.r,
|
||||
.g = if (c.g) |_g| _g else self.g,
|
||||
.b = if (c.b) |_b| _b else self.b,
|
||||
.a = if (c.a) |_a| _a else self.a,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn lerp(self: @This(), other: @This(), t: f32) @This() {
|
||||
return self.toVector4().lerp(other.toVector4(), t).toColor();
|
||||
}
|
||||
|
||||
pub fn lerpA(self: @This(), targetAlpha: u8, t: f32) @This() {
|
||||
var copy = self;
|
||||
const a = @as(f32, @floatFromInt(self.a));
|
||||
copy.a = @as(u8, @intFromFloat(a * (1 - t) + @as(f32, @floatFromInt(targetAlpha)) * t));
|
||||
return copy;
|
||||
}
|
||||
|
||||
pub fn toVector4(self: @This()) Vector4 {
|
||||
return .{
|
||||
.x = @as(f32, @floatFromInt(self.r)) / 255.0,
|
||||
.y = @as(f32, @floatFromInt(self.g)) / 255.0,
|
||||
.z = @as(f32, @floatFromInt(self.b)) / 255.0,
|
||||
.w = @as(f32, @floatFromInt(self.a)) / 255.0,
|
||||
};
|
||||
}
|
||||
|
||||
/// negate color (keep alpha)
|
||||
pub fn neg(self: @This()) @This() {
|
||||
return .{
|
||||
.r = 255 - self.r,
|
||||
.g = 255 - self.g,
|
||||
.b = 255 - self.b,
|
||||
.a = self.a,
|
||||
};
|
||||
}
|
||||
};
|
||||
|
||||
/// Camera2D, defines position/orientation in 2d space
|
||||
pub const Camera2D = extern struct {
|
||||
/// Camera offset (displacement from target)
|
||||
offset: Vector2 = Vector2.zero(),
|
||||
/// Camera target (rotation and zoom origin)
|
||||
target: Vector2,
|
||||
/// Camera rotation in degrees
|
||||
rotation: f32 = 0,
|
||||
/// Camera zoom (scaling), should be 1.0f by default
|
||||
zoom: f32 = 1,
|
||||
};
|
||||
|
||||
pub const MATERIAL_MAP_DIFFUSE = @as(usize, @intCast(@intFromEnum(MaterialMapIndex.MATERIAL_MAP_ALBEDO)));
|
||||
pub const MATERIAL_MAP_SPECULAR = @as(usize, @intCast(@intFromEnum(MaterialMapIndex.MATERIAL_MAP_METALNESS)));
|
||||
|
||||
//--- callbacks -----------------------------------------------------------------------------------
|
||||
|
||||
/// Logging: Redirect trace log messages
|
||||
pub const TraceLogCallback = *const fn (logLevel: c_int, text: [*c]const u8, args: ?*anyopaque) void;
|
||||
|
||||
/// FileIO: Load binary data
|
||||
pub const LoadFileDataCallback = *const fn (fileName: [*c]const u8, bytesRead: [*c]c_uint) [*c]u8;
|
||||
|
||||
/// FileIO: Save binary data
|
||||
pub const SaveFileDataCallback = *const fn (fileName: [*c]const u8, data: ?*anyopaque, bytesToWrite: c_uint) bool;
|
||||
|
||||
/// FileIO: Load text data
|
||||
pub const LoadFileTextCallback = *const fn (fileName: [*c]const u8) [*c]u8;
|
||||
|
||||
/// FileIO: Save text data
|
||||
pub const SaveFileTextCallback = *const fn (fileName: [*c]const u8, text: [*c]const u8) bool;
|
||||
|
||||
/// Audio Loading and Playing Functions (Module: audio)
|
||||
pub const AudioCallback = *const fn (bufferData: ?*anyopaque, frames: u32) void;
|
||||
|
||||
//--- utils ---------------------------------------------------------------------------------------
|
||||
|
||||
// Camera global state context data [56 bytes]
|
||||
pub const CameraData = extern struct {
|
||||
/// Current camera mode
|
||||
mode: u32,
|
||||
/// Camera distance from position to target
|
||||
targetDistance: f32,
|
||||
/// Player eyes position from ground (in meters)
|
||||
playerEyesPosition: f32,
|
||||
/// Camera angle in plane XZ
|
||||
angle: Vector2,
|
||||
/// Previous mouse position
|
||||
previousMousePosition: Vector2,
|
||||
|
||||
// Camera movement control keys
|
||||
|
||||
/// Move controls (CAMERA_FIRST_PERSON)
|
||||
moveControl: i32[6],
|
||||
/// Smooth zoom control key
|
||||
smoothZoomControl: i32,
|
||||
/// Alternative control key
|
||||
altControl: i32,
|
||||
/// Pan view control key
|
||||
panControl: i32,
|
||||
};
|
||||
|
||||
pub fn randomF32(rng: std.rand.Random, min: f32, max: f32) f32 {
|
||||
return rng.float(f32) * (max - min) + min;
|
||||
}
|
||||
|
||||
//--- functions -----------------------------------------------------------------------------------
|
||||
|
||||
/// Setup init configuration flags (view FLAGS)
|
||||
pub fn SetConfigFlags(
|
||||
flags: ConfigFlags,
|
||||
) void {
|
||||
raylib.SetConfigFlags(@as(c_uint, @bitCast(flags)));
|
||||
}
|
||||
|
||||
/// Load file data as byte array (read)
|
||||
pub fn LoadFileData(fileName: [*:0]const u8) ![]const u8 {
|
||||
var bytesRead: u32 = undefined;
|
||||
const data = raylib.LoadFileData(
|
||||
@as([*c]const u8, @ptrFromInt(@intFromPtr(fileName))),
|
||||
@as([*c]c_int, @ptrCast(&bytesRead)),
|
||||
);
|
||||
|
||||
if (data == null) return error.FileNotFound;
|
||||
|
||||
return data[0..bytesRead];
|
||||
}
|
||||
|
||||
/// Unload file data allocated by LoadFileData()
|
||||
pub fn UnloadFileData(
|
||||
data: []const u8,
|
||||
) void {
|
||||
raylib.UnloadFileData(
|
||||
@as([*c]u8, @ptrFromInt(@intFromPtr(data.ptr))),
|
||||
);
|
||||
}
|
||||
|
||||
/// Set custom trace log
|
||||
pub fn SetTraceLogCallback(
|
||||
_: TraceLogCallback,
|
||||
) void {
|
||||
@panic("use log.zig for that");
|
||||
}
|
||||
|
||||
/// Generate image font atlas using chars info
|
||||
pub fn GenImageFontAtlas(
|
||||
chars: [*]const GlyphInfo,
|
||||
recs: [*]const [*]const Rectangle,
|
||||
glyphCount: i32,
|
||||
fontSize: i32,
|
||||
padding: i32,
|
||||
packMethod: i32,
|
||||
) Image {
|
||||
var out: Image = undefined;
|
||||
mGenImageFontAtlas(
|
||||
@as([*c]raylib.Image, @ptrCast(&out)),
|
||||
@as([*c]raylib.GlyphInfo, @ptrCast(chars)),
|
||||
@as([*c][*c]raylib.Rectangle, @ptrCast(recs)),
|
||||
glyphCount,
|
||||
fontSize,
|
||||
padding,
|
||||
packMethod,
|
||||
);
|
||||
return out;
|
||||
}
|
||||
export fn mGenImageFontAtlas(
|
||||
out: [*c]raylib.Image,
|
||||
chars: [*c]raylib.GlyphInfo,
|
||||
recs: [*c][*c]raylib.Rectangle,
|
||||
glyphCount: i32,
|
||||
fontSize: i32,
|
||||
padding: i32,
|
||||
packMethod: i32,
|
||||
) void {
|
||||
out.* = raylib.GenImageFontAtlas(
|
||||
chars,
|
||||
recs,
|
||||
glyphCount,
|
||||
fontSize,
|
||||
padding,
|
||||
packMethod,
|
||||
);
|
||||
}
|
||||
|
||||
/// Get native window handle
|
||||
pub fn GetWindowHandle() ?*anyopaque {
|
||||
return raylib.GetWindowHandle();
|
||||
}
|
||||
|
||||
/// Internal memory allocator
|
||||
pub fn MemAlloc(
|
||||
size: i32,
|
||||
) ?*anyopaque {
|
||||
return raylib.MemAlloc(size);
|
||||
}
|
||||
|
||||
/// Internal memory reallocator
|
||||
pub fn MemRealloc(
|
||||
ptr: ?*anyopaque,
|
||||
size: i32,
|
||||
) ?*anyopaque {
|
||||
return raylib.MemRealloc(ptr, size);
|
||||
}
|
||||
|
||||
/// Internal memory free
|
||||
pub fn MemFree(
|
||||
ptr: ?*anyopaque,
|
||||
) void {
|
||||
raylib.MemFree(ptr);
|
||||
}
|
||||
|
||||
/// Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
|
||||
pub fn TraceLog(
|
||||
logLevel: i32,
|
||||
text: [*:0]const u8,
|
||||
) void {
|
||||
raylib.TraceLog(logLevel, text);
|
||||
}
|
||||
|
||||
/// Text formatting with variables (sprintf() style)
|
||||
/// caller owns memory
|
||||
pub fn TextFormat(allocator: std.mem.Allocator, comptime fmt: []const u8, args: anytype) std.fmt.AllocPrintError![*:0]const u8 {
|
||||
return (try std.fmt.allocPrintZ(allocator, fmt, args)).ptr;
|
||||
}
|
||||
|
||||
/// Split text into multiple strings
|
||||
pub fn TextSplit(allocator: std.mem.Allocator, text: []const u8, delimiter: []const u8, count: i32) ![]const []const u8 {
|
||||
var list = std.ArrayList([]const u8).init(allocator);
|
||||
var it = std.mem.split(u8, text, delimiter);
|
||||
var i = 0;
|
||||
var n = 0;
|
||||
while (it.next()) |slice| : (i += 1) {
|
||||
if (i >= count) {
|
||||
break;
|
||||
}
|
||||
|
||||
try list.append(slice);
|
||||
n += slice.len;
|
||||
}
|
||||
if (n < text.len) {
|
||||
try list.append(text[n..]);
|
||||
}
|
||||
return list.toOwnedSlice();
|
||||
}
|
||||
|
||||
/// Join text strings with delimiter
|
||||
pub fn TextJoin(allocator: std.mem.Allocator, textList: []const []const u8, delimiter: []const u8) ![:0]const u8 {
|
||||
return (try std.mem.joinZ(allocator, delimiter, textList)).ptr;
|
||||
}
|
||||
|
||||
/// Append text at specific position and move cursor!
|
||||
pub fn TextAppend(allocator: std.mem.Allocator, text: []const u8, append: []const u8, position: i32) std.fmt.AllocPrintError![:0]u8 {
|
||||
return (try std.fmt.allocPrintZ(allocator, "{s}{s}{s}", .{
|
||||
text[0..position],
|
||||
append,
|
||||
text[position..],
|
||||
})).ptr;
|
||||
}
|
||||
|
||||
//--- RLGL ----------------------------------------------------------------------------------------
|
||||
|
||||
pub const DEG2RAD: f32 = PI / 180;
|
||||
pub const RAD2DEG: f32 = 180 / PI;
|
||||
|
||||
///
|
||||
pub const rlglData = extern struct {
|
||||
/// Current render batch
|
||||
currentBatch: ?*rlRenderBatch,
|
||||
/// Default internal render batch
|
||||
defaultBatch: rlRenderBatch,
|
||||
|
||||
pub const State = extern struct {
|
||||
/// Current active render batch vertex counter (generic, used for all batches)
|
||||
vertexCounter: i32,
|
||||
/// Current active texture coordinate X (added on glVertex*())
|
||||
texcoordx: f32,
|
||||
/// Current active texture coordinate Y (added on glVertex*())
|
||||
texcoordy: f32,
|
||||
/// Current active normal X (added on glVertex*())
|
||||
normalx: f32,
|
||||
/// Current active normal Y (added on glVertex*())
|
||||
normaly: f32,
|
||||
/// Current active normal Z (added on glVertex*())
|
||||
normalz: f32,
|
||||
/// Current active color R (added on glVertex*())
|
||||
colorr: u8,
|
||||
/// Current active color G (added on glVertex*())
|
||||
colorg: u8,
|
||||
/// Current active color B (added on glVertex*())
|
||||
colorb: u8,
|
||||
/// Current active color A (added on glVertex*())
|
||||
colora: u8,
|
||||
/// Current matrix mode
|
||||
currentMatrixMode: i32,
|
||||
/// Current matrix pointer
|
||||
currentMatrix: ?*Matrix,
|
||||
/// Default modelview matrix
|
||||
modelview: Matrix,
|
||||
/// Default projection matrix
|
||||
projection: Matrix,
|
||||
/// Transform matrix to be used with rlTranslate, rlRotate, rlScale
|
||||
transform: Matrix,
|
||||
/// Require transform matrix application to current draw-call vertex (if required)
|
||||
transformRequired: bool,
|
||||
/// Matrix stack for push/pop
|
||||
stack: [RL_MAX_MATRIX_STACK_SIZE]Matrix,
|
||||
/// Matrix stack counter
|
||||
stackCounter: i32,
|
||||
/// Default texture used on shapes/poly drawing (required by shader)
|
||||
defaultTextureId: u32,
|
||||
/// Active texture ids to be enabled on batch drawing (0 active by default)
|
||||
activeTextureId: [RL_DEFAULT_BATCH_MAX_TEXTURE_UNITS]u32,
|
||||
/// Default vertex shader id (used by default shader program)
|
||||
defaultVShaderId: u32,
|
||||
/// Default fragment shader id (used by default shader program)
|
||||
defaultFShaderId: u32,
|
||||
/// Default shader program id, supports vertex color and diffuse texture
|
||||
defaultShaderId: u32,
|
||||
/// Default shader locations pointer to be used on rendering
|
||||
defaultShaderLocs: [*]i32,
|
||||
/// Current shader id to be used on rendering (by default, defaultShaderId)
|
||||
currentShaderId: u32,
|
||||
/// Current shader locations pointer to be used on rendering (by default, defaultShaderLocs)
|
||||
currentShaderLocs: [*]i32,
|
||||
/// Stereo rendering flag
|
||||
stereoRender: bool,
|
||||
/// VR stereo rendering eyes projection matrices
|
||||
projectionStereo: [2]Matrix,
|
||||
/// VR stereo rendering eyes view offset matrices
|
||||
viewOffsetStereo: [2]Matrix,
|
||||
/// Blending mode active
|
||||
currentBlendMode: i32,
|
||||
/// Blending source factor
|
||||
glBlendSrcFactor: i32,
|
||||
/// Blending destination factor
|
||||
glBlendDstFactor: i32,
|
||||
/// Blending equation
|
||||
glBlendEquation: i32,
|
||||
/// Current framebuffer width
|
||||
framebufferWidth: i32,
|
||||
/// Current framebuffer height
|
||||
framebufferHeight: i32,
|
||||
};
|
||||
|
||||
pub const ExtSupported = extern struct {
|
||||
/// VAO support (OpenGL ES2 could not support VAO extension) (GL_ARB_vertex_array_object)
|
||||
vao: bool,
|
||||
/// Instancing supported (GL_ANGLE_instanced_arrays, GL_EXT_draw_instanced + GL_EXT_instanced_arrays)
|
||||
instancing: bool,
|
||||
/// NPOT textures full support (GL_ARB_texture_non_power_of_two, GL_OES_texture_npot)
|
||||
texNPOT: bool,
|
||||
/// Depth textures supported (GL_ARB_depth_texture, GL_WEBGL_depth_texture, GL_OES_depth_texture)
|
||||
texDepth: bool,
|
||||
/// float textures support (32 bit per channel) (GL_OES_texture_float)
|
||||
texFloat32: bool,
|
||||
/// DDS texture compression support (GL_EXT_texture_compression_s3tc, GL_WEBGL_compressed_texture_s3tc, GL_WEBKIT_WEBGL_compressed_texture_s3tc)
|
||||
texCompDXT: bool,
|
||||
/// ETC1 texture compression support (GL_OES_compressed_ETC1_RGB8_texture, GL_WEBGL_compressed_texture_etc1)
|
||||
texCompETC1: bool,
|
||||
/// ETC2/EAC texture compression support (GL_ARB_ES3_compatibility)
|
||||
texCompETC2: bool,
|
||||
/// PVR texture compression support (GL_IMG_texture_compression_pvrtc)
|
||||
texCompPVRT: bool,
|
||||
/// ASTC texture compression support (GL_KHR_texture_compression_astc_hdr, GL_KHR_texture_compression_astc_ldr)
|
||||
texCompASTC: bool,
|
||||
/// Clamp mirror wrap mode supported (GL_EXT_texture_mirror_clamp)
|
||||
texMirrorClamp: bool,
|
||||
/// Anisotropic texture filtering support (GL_EXT_texture_filter_anisotropic)
|
||||
texAnisoFilter: bool,
|
||||
/// Compute shaders support (GL_ARB_compute_shader)
|
||||
computeShader: bool,
|
||||
/// Shader storage buffer object support (GL_ARB_shader_storage_buffer_object)
|
||||
ssbo: bool,
|
||||
/// Maximum anisotropy level supported (minimum is 2.0f)
|
||||
maxAnisotropyLevel: f32,
|
||||
/// Maximum bits for depth component
|
||||
maxDepthBits: i32,
|
||||
};
|
||||
};
|
||||
|
||||
/// Enable attribute state pointer
|
||||
pub fn rlEnableStatePointer(
|
||||
vertexAttribType: i32,
|
||||
buffer: *anyopaque,
|
||||
) void {
|
||||
raylib.rlEnableStatePointer(
|
||||
vertexAttribType,
|
||||
@as([*c]anyopaque, @ptrCast(buffer)),
|
||||
);
|
||||
}
|
||||
|
||||
/// Disable attribute state pointer
|
||||
pub fn rlDisableStatePointer(
|
||||
vertexAttribType: i32,
|
||||
) void {
|
||||
raylib.rlDisableStatePointer(
|
||||
vertexAttribType,
|
||||
);
|
||||
}
|
||||
|
||||
/// Get the last gamepad button pressed
|
||||
pub fn GetGamepadButtonPressed() ?GamepadButton {
|
||||
if (raylib.GetGamepadButtonPressed() == -1) return null;
|
||||
|
||||
return @as(GamepadButton, @enumFromInt(raylib.GetGamepadButtonPressed()));
|
||||
}
|
||||
48
libs/raylib/intermediate.zig
Normal file
48
libs/raylib/intermediate.zig
Normal file
@ -0,0 +1,48 @@
|
||||
const std = @import("std");
|
||||
const fs = std.fs;
|
||||
const mapping = @import("type_mapping.zig");
|
||||
const json = std.json;
|
||||
|
||||
pub const jsonFiles: []const []const u8 = &.{
|
||||
"raylib.json",
|
||||
"rlgl.json",
|
||||
"raymath.json",
|
||||
};
|
||||
pub const bindingsJSON = "bindings.json";
|
||||
|
||||
pub fn main() !void {
|
||||
std.log.info("updating bindings.json ...", .{});
|
||||
var gpa = std.heap.GeneralPurposeAllocator(.{}){};
|
||||
defer {
|
||||
if (gpa.deinit() == .leak) {
|
||||
std.log.err("memory leak detected", .{});
|
||||
}
|
||||
}
|
||||
const allocator = gpa.allocator();
|
||||
var arena = std.heap.ArenaAllocator.init(allocator);
|
||||
defer arena.deinit();
|
||||
|
||||
const raylib: mapping.CombinedRaylib = try mapping.CombinedRaylib.load(arena.allocator(), jsonFiles);
|
||||
|
||||
var bindings: mapping.Intermediate = mapping.Intermediate.loadCustoms(arena.allocator(), bindingsJSON) catch |err| Catch: {
|
||||
std.log.warn("could not open {s}: {?}\n", .{ bindingsJSON, err });
|
||||
break :Catch mapping.Intermediate{
|
||||
.enums = &[_]mapping.Enum{},
|
||||
.structs = &[_]mapping.Struct{},
|
||||
.functions = &[_]mapping.Function{},
|
||||
.defines = &[_]mapping.Define{},
|
||||
};
|
||||
};
|
||||
|
||||
try bindings.addNonCustom(arena.allocator(), raylib);
|
||||
|
||||
var file = try fs.cwd().createFile(bindingsJSON, .{});
|
||||
defer file.close();
|
||||
|
||||
try json.stringify(bindings, .{
|
||||
.emit_null_optional_fields = false,
|
||||
.whitespace = .indent_2,
|
||||
}, file.writer());
|
||||
|
||||
std.log.info("... done", .{});
|
||||
}
|
||||
BIN
libs/raylib/logo.png
Normal file
BIN
libs/raylib/logo.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 1.1 KiB |
4035
libs/raylib/marshal.c
Normal file
4035
libs/raylib/marshal.c
Normal file
File diff suppressed because it is too large
Load Diff
2429
libs/raylib/marshal.h
Normal file
2429
libs/raylib/marshal.h
Normal file
File diff suppressed because it is too large
Load Diff
1
libs/raylib/raylib
Submodule
1
libs/raylib/raylib
Submodule
@ -0,0 +1 @@
|
||||
Subproject commit e46b6147fc30e69dd300bbda90ff0a62bf8a4df0
|
||||
11660
libs/raylib/raylib.json
Normal file
11660
libs/raylib/raylib.json
Normal file
File diff suppressed because it is too large
Load Diff
12171
libs/raylib/raylib.zig
Normal file
12171
libs/raylib/raylib.zig
Normal file
File diff suppressed because it is too large
Load Diff
6
libs/raylib/raylib_parser.zig
Normal file
6
libs/raylib/raylib_parser.zig
Normal file
@ -0,0 +1,6 @@
|
||||
//! run 'zig build jsons' to generate bindings for raylib
|
||||
//! run 'zig build raylib_parser' to build the raylib_parser.exe
|
||||
|
||||
/// this needs to be here so the zig compiler won't complain that there is no entry point
|
||||
/// but actually we are using main() of 'raylib/src/parser/raylib_parser.c'
|
||||
pub extern fn main() c_int;
|
||||
1954
libs/raylib/raymath.json
Normal file
1954
libs/raylib/raymath.json
Normal file
File diff suppressed because it is too large
Load Diff
3928
libs/raylib/rlgl.json
Normal file
3928
libs/raylib/rlgl.json
Normal file
File diff suppressed because it is too large
Load Diff
691
libs/raylib/type_mapping.zig
Normal file
691
libs/raylib/type_mapping.zig
Normal file
@ -0,0 +1,691 @@
|
||||
//! Strategy:
|
||||
//! 1. generate raylib JSONs
|
||||
//! 2. combine in a union RaylibJson
|
||||
//! 3. convert to intermediate representation
|
||||
//! 4. read adjusted intermediate JSONs
|
||||
//! 5. generate raylib.zig // wrap paramters and pass them to marshall versions of the raylib functions
|
||||
//! 6. generate marshall.c // unwrap parameters from zig function and call the actual raylib function
|
||||
//! 7. generate marshall.h // C signatures for all marshalled functions
|
||||
|
||||
const std = @import("std");
|
||||
const json = std.json;
|
||||
const memoryConstrain: usize = 1024 * 1024 * 1024; // 1 GiB
|
||||
const Allocator = std.mem.Allocator;
|
||||
const fmt = std.fmt.allocPrint;
|
||||
const talloc = std.testing.allocator;
|
||||
const expect = std.testing.expect;
|
||||
const expectEqualStrings = std.testing.expectEqualStrings;
|
||||
|
||||
//--- Intermediate Format -------------------------------------------------------------------------
|
||||
|
||||
pub const Intermediate = struct {
|
||||
functions: []Function,
|
||||
enums: []Enum,
|
||||
structs: []Struct,
|
||||
defines: []Define,
|
||||
|
||||
pub fn loadCustoms(allocator: Allocator, jsonFile: []const u8) !@This() {
|
||||
var enums = std.ArrayList(Enum).init(allocator);
|
||||
var structs = std.ArrayList(Struct).init(allocator);
|
||||
var functions = std.ArrayList(Function).init(allocator);
|
||||
var defines = std.ArrayList(Define).init(allocator);
|
||||
|
||||
const jsonData = try std.fs.cwd().readFileAlloc(allocator, jsonFile, memoryConstrain);
|
||||
|
||||
const bindingJson = try json.parseFromSliceLeaky(Intermediate, allocator, jsonData, .{
|
||||
.ignore_unknown_fields = true,
|
||||
});
|
||||
|
||||
for (bindingJson.enums) |t| {
|
||||
if (t.custom) {
|
||||
try enums.append(t);
|
||||
}
|
||||
}
|
||||
|
||||
for (bindingJson.structs) |t| {
|
||||
if (t.custom) {
|
||||
try structs.append(t);
|
||||
}
|
||||
}
|
||||
|
||||
for (bindingJson.functions) |f| {
|
||||
if (f.custom) {
|
||||
try functions.append(f);
|
||||
}
|
||||
}
|
||||
|
||||
for (bindingJson.defines) |f| {
|
||||
if (f.custom) {
|
||||
try defines.append(f);
|
||||
}
|
||||
}
|
||||
|
||||
return @This(){
|
||||
.enums = try enums.toOwnedSlice(),
|
||||
.structs = try structs.toOwnedSlice(),
|
||||
.functions = try functions.toOwnedSlice(),
|
||||
.defines = try defines.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
pub fn addNonCustom(self: *@This(), allocator: Allocator, rlJson: CombinedRaylib) !void {
|
||||
var enums = std.ArrayList(Enum).init(allocator);
|
||||
try enums.appendSlice(self.enums);
|
||||
var structs = std.ArrayList(Struct).init(allocator);
|
||||
try structs.appendSlice(self.structs);
|
||||
var functions = std.ArrayList(Function).init(allocator);
|
||||
try functions.appendSlice(self.functions);
|
||||
var defines = std.ArrayList(Define).init(allocator);
|
||||
try defines.appendSlice(self.defines);
|
||||
|
||||
outer: for (rlJson.defines.values(), 0..) |d, i| {
|
||||
for (defines.items) |added| {
|
||||
if (eql(added.name, d.name)) {
|
||||
std.log.debug("{s} is customized", .{d.name});
|
||||
continue :outer;
|
||||
}
|
||||
}
|
||||
const define = parseRaylibDefine(allocator, d) orelse continue :outer;
|
||||
|
||||
if (i < defines.items.len) {
|
||||
try defines.insert(i, define);
|
||||
} else {
|
||||
try defines.append(define);
|
||||
}
|
||||
}
|
||||
outer: for (rlJson.enums.values(), 0..) |e, i| {
|
||||
const name = if (alias.get(e.name)) |n| n else e.name;
|
||||
for (enums.items) |added| {
|
||||
if (eql(added.name, name)) {
|
||||
std.log.debug("{s} is customized", .{name});
|
||||
continue :outer;
|
||||
}
|
||||
}
|
||||
|
||||
if (i < enums.items.len) {
|
||||
try enums.insert(i, try parseRaylibEnum(allocator, e));
|
||||
} else {
|
||||
try enums.append(try parseRaylibEnum(allocator, e));
|
||||
}
|
||||
}
|
||||
outer: for (rlJson.structs.values(), 0..) |s, i| {
|
||||
const name = if (alias.get(s.name)) |n| n else s.name;
|
||||
for (structs.items) |added| {
|
||||
if (eql(added.name, name)) {
|
||||
std.log.debug("{s} is customized", .{name});
|
||||
continue :outer;
|
||||
}
|
||||
}
|
||||
if (i < structs.items.len) {
|
||||
try structs.insert(i, try parseRaylibStruct(allocator, s));
|
||||
} else {
|
||||
try structs.append(try parseRaylibStruct(allocator, s));
|
||||
}
|
||||
}
|
||||
for (rlJson.defines.values()) |_| {}
|
||||
|
||||
outer: for (rlJson.functions.values(), 0..) |f, i| {
|
||||
for (functions.items) |added| {
|
||||
if (eql(added.name, f.name)) {
|
||||
std.log.debug("{s} is customized", .{f.name});
|
||||
continue :outer;
|
||||
}
|
||||
}
|
||||
if (i < functions.items.len) {
|
||||
try functions.insert(i, try parseRaylibFunction(allocator, f));
|
||||
} else {
|
||||
try functions.append(try parseRaylibFunction(allocator, f));
|
||||
}
|
||||
}
|
||||
|
||||
self.enums = try enums.toOwnedSlice();
|
||||
self.structs = try structs.toOwnedSlice();
|
||||
self.functions = try functions.toOwnedSlice();
|
||||
self.defines = try defines.toOwnedSlice();
|
||||
}
|
||||
|
||||
pub fn containsStruct(self: @This(), name: []const u8) bool {
|
||||
for (self.structs) |s| {
|
||||
if (eql(s.name, name)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
pub fn containsEnum(self: @This(), name: []const u8) bool {
|
||||
for (self.enums) |e| {
|
||||
if (eql(e.name, name)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
pub fn containsDefine(self: @This(), name: []const u8) bool {
|
||||
for (self.defines) |d| {
|
||||
if (eql(d.name, name)) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
pub const Function = struct {
|
||||
name: []const u8,
|
||||
params: []FunctionParameter,
|
||||
returnType: []const u8,
|
||||
description: ?[]const u8 = null,
|
||||
custom: bool = false,
|
||||
};
|
||||
|
||||
pub const FunctionParameter = struct {
|
||||
name: []const u8,
|
||||
typ: []const u8,
|
||||
description: ?[]const u8 = null,
|
||||
};
|
||||
|
||||
pub fn parseRaylibFunction(allocator: Allocator, func: RaylibFunction) !Function {
|
||||
var args = std.ArrayList(FunctionParameter).init(allocator);
|
||||
if (func.params) |params| {
|
||||
for (params) |p| {
|
||||
const t = try toZig(allocator, p.type);
|
||||
|
||||
try args.append(.{
|
||||
.name = p.name,
|
||||
.typ = t,
|
||||
.description = p.description,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
const returnType = try toZig(allocator, func.returnType);
|
||||
|
||||
return Function{
|
||||
.name = func.name,
|
||||
.params = try args.toOwnedSlice(),
|
||||
.returnType = returnType,
|
||||
.description = func.description,
|
||||
};
|
||||
}
|
||||
|
||||
pub const Struct = struct {
|
||||
name: []const u8,
|
||||
fields: []const StructField,
|
||||
description: ?[]const u8 = null,
|
||||
custom: bool = false,
|
||||
};
|
||||
|
||||
pub const StructField = struct {
|
||||
name: []const u8,
|
||||
typ: []const u8,
|
||||
description: ?[]const u8 = null,
|
||||
};
|
||||
|
||||
pub fn parseRaylibStruct(allocator: Allocator, s: RaylibStruct) !Struct {
|
||||
var fields = std.ArrayList(StructField).init(allocator);
|
||||
for (s.fields) |field| {
|
||||
var typ = try toZig(allocator, getTypeWithoutArrayNotation(field.type));
|
||||
|
||||
if (getArraySize(field.type)) |size| {
|
||||
typ = try std.fmt.allocPrint(allocator, "[{d}]{s}", .{ size, typ });
|
||||
}
|
||||
|
||||
try fields.append(.{
|
||||
.name = field.name,
|
||||
.typ = typ,
|
||||
.description = field.description,
|
||||
});
|
||||
}
|
||||
|
||||
return Struct{
|
||||
.name = if (alias.get(s.name)) |a| a else s.name,
|
||||
.fields = try fields.toOwnedSlice(),
|
||||
.description = s.description,
|
||||
};
|
||||
}
|
||||
|
||||
pub const Define = struct {
|
||||
name: []const u8,
|
||||
typ: []const u8,
|
||||
value: []const u8,
|
||||
description: ?[]const u8 = null,
|
||||
custom: bool = false,
|
||||
};
|
||||
|
||||
pub fn parseRaylibDefine(allocator: Allocator, s: RaylibDefine) ?Define {
|
||||
var typ: []const u8 = undefined;
|
||||
var value: []const u8 = undefined;
|
||||
|
||||
if (eql("INT", s.type)) {
|
||||
typ = "i32";
|
||||
value = std.fmt.allocPrint(allocator, "{s}", .{s.value}) catch return null;
|
||||
} else if (eql("LONG", s.type)) {
|
||||
typ = "i64";
|
||||
value = std.fmt.allocPrint(allocator, "{s}", .{s.value}) catch return null;
|
||||
} else if (eql("FLOAT", s.type)) {
|
||||
typ = "f32";
|
||||
value = std.fmt.allocPrint(allocator, "{s}", .{s.value}) catch return null;
|
||||
} else if (eql("DOUBLE", s.type)) {
|
||||
typ = "f64";
|
||||
value = std.fmt.allocPrint(allocator, "{s}", .{s.value}) catch return null;
|
||||
} else if (eql("STRING", s.type)) {
|
||||
typ = "[]const u8";
|
||||
value = std.fmt.allocPrint(allocator, "\"{s}\"", .{s.value}) catch return null;
|
||||
} else if (eql("COLOR", s.type)) {
|
||||
typ = "Color";
|
||||
std.debug.assert(startsWith(s.value, "CLITERAL(Color){"));
|
||||
std.debug.assert(endsWith(s.value, "}"));
|
||||
|
||||
const componentString = s.value["CLITERAL(Color){".len .. s.value.len - 1];
|
||||
var spliterator = std.mem.split(u8, componentString, ",");
|
||||
var r = spliterator.next() orelse return null;
|
||||
r = std.mem.trim(u8, r, " \t\r\n");
|
||||
var g = spliterator.next() orelse return null;
|
||||
g = std.mem.trim(u8, g, " \t\r\n");
|
||||
var b = spliterator.next() orelse return null;
|
||||
b = std.mem.trim(u8, b, " \t\r\n");
|
||||
var a = spliterator.next() orelse return null;
|
||||
a = std.mem.trim(u8, a, " \t\r\n");
|
||||
value = std.fmt.allocPrint(allocator, ".{{.r={s}, .g={s}, .b={s}, .a={s}}}", .{ r, g, b, a }) catch return null;
|
||||
} else {
|
||||
return null;
|
||||
}
|
||||
|
||||
return Define{
|
||||
.name = s.name,
|
||||
.typ = typ,
|
||||
.value = value,
|
||||
.description = s.description,
|
||||
};
|
||||
}
|
||||
|
||||
pub const Enum = struct {
|
||||
name: []const u8,
|
||||
values: []const EnumValue,
|
||||
description: ?[]const u8 = null,
|
||||
custom: bool = false,
|
||||
};
|
||||
|
||||
pub const EnumValue = struct {
|
||||
name: []const u8,
|
||||
value: c_int,
|
||||
description: ?[]const u8 = null,
|
||||
};
|
||||
|
||||
pub fn parseRaylibEnum(allocator: Allocator, e: RaylibEnum) !Enum {
|
||||
var values = std.ArrayList(EnumValue).init(allocator);
|
||||
for (e.values) |value| {
|
||||
try values.append(.{
|
||||
.name = value.name,
|
||||
.value = value.value,
|
||||
.description = value.description,
|
||||
});
|
||||
}
|
||||
|
||||
return Enum{
|
||||
.name = e.name,
|
||||
.values = try values.toOwnedSlice(),
|
||||
.description = e.description,
|
||||
};
|
||||
}
|
||||
|
||||
/// is c const type
|
||||
pub fn isConst(c: []const u8) bool {
|
||||
return startsWith(c, "const ");
|
||||
}
|
||||
test "isConst" {
|
||||
try expect(!isConst("char *"));
|
||||
try expect(!isConst("unsigned char *"));
|
||||
try expect(isConst("const unsigned char *"));
|
||||
try expect(isConst("const unsigned int *"));
|
||||
try expect(isConst("const void *"));
|
||||
try expect(!isConst("Vector2 *"));
|
||||
try expect(!isConst("Vector2"));
|
||||
try expect(!isConst("int"));
|
||||
}
|
||||
|
||||
/// is c pointer type
|
||||
pub fn isPointer(c: []const u8) bool {
|
||||
return endsWith(c, "*");
|
||||
}
|
||||
test "isPointer" {
|
||||
try expect(isPointer("char *"));
|
||||
try expect(isPointer("unsigned char *"));
|
||||
try expect(isPointer("const unsigned char *"));
|
||||
try expect(isPointer("const unsigned int *"));
|
||||
try expect(isPointer("Vector2 *"));
|
||||
try expect(!isPointer("Vector2"));
|
||||
try expect(!isPointer("int"));
|
||||
}
|
||||
|
||||
pub fn isPointerToPointer(c: []const u8) bool {
|
||||
return endsWith(c, "**");
|
||||
}
|
||||
test "isPointerToPointer" {
|
||||
try expect(!isPointerToPointer("char *"));
|
||||
try expect(!isPointerToPointer("unsigned char *"));
|
||||
try expect(isPointerToPointer("const unsigned char **"));
|
||||
try expect(isPointerToPointer("const unsigned int **"));
|
||||
try expect(isPointerToPointer("Vector2 **"));
|
||||
try expect(!isPointerToPointer("Vector2*"));
|
||||
try expect(!isPointerToPointer("int"));
|
||||
}
|
||||
|
||||
pub fn isVoid(c: []const u8) bool {
|
||||
return eql(stripType(c), "void");
|
||||
}
|
||||
test "isVoid" {
|
||||
try expect(!isVoid("char *"));
|
||||
try expect(!isVoid("unsigned char *"));
|
||||
try expect(!isVoid("const unsigned char *"));
|
||||
try expect(isVoid("const void *"));
|
||||
try expect(isVoid("void *"));
|
||||
try expect(isVoid("void"));
|
||||
try expect(isVoid("void **"));
|
||||
}
|
||||
|
||||
/// strips const and pointer annotations
|
||||
/// const TName * -> TName
|
||||
pub fn stripType(c: []const u8) []const u8 {
|
||||
var name = if (isConst(c)) c["const ".len..] else c;
|
||||
name = if (isPointer(name)) name[0 .. name.len - 1] else name;
|
||||
// double pointer?
|
||||
name = if (isPointer(name)) name[0 .. name.len - 1] else name;
|
||||
name = std.mem.trim(u8, name, " \t\n");
|
||||
if (alias.get(name)) |ali| {
|
||||
name = ali;
|
||||
}
|
||||
return name;
|
||||
}
|
||||
test "stripType" {
|
||||
try expectEqualStrings("void", stripType("const void *"));
|
||||
try expectEqualStrings("unsinged int", stripType("unsinged int *"));
|
||||
try expectEqualStrings("Vector2", stripType("const Vector2 *"));
|
||||
}
|
||||
|
||||
pub fn getArraySize(typ: []const u8) ?usize {
|
||||
if (std.mem.indexOf(u8, typ, "[")) |open| {
|
||||
if (std.mem.indexOf(u8, typ, "]")) |close| {
|
||||
return std.fmt.parseInt(usize, typ[open + 1 .. close], 10) catch null;
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
test "getArraySize" {
|
||||
const expectEqual = std.testing.expectEqual;
|
||||
|
||||
try expectEqual(@as(?usize, 4), getArraySize("float[4]"));
|
||||
try expectEqual(@as(?usize, 44), getArraySize("int[44]"));
|
||||
try expectEqual(@as(?usize, 123456), getArraySize("a[123456]"));
|
||||
try expectEqual(@as(?usize, 1), getArraySize("test[1] "));
|
||||
try expectEqual(@as(?usize, null), getArraySize("foo[]"));
|
||||
try expectEqual(@as(?usize, null), getArraySize("bar"));
|
||||
try expectEqual(@as(?usize, null), getArraySize("foo["));
|
||||
try expectEqual(@as(?usize, null), getArraySize("bar]"));
|
||||
try expectEqual(@as(?usize, 42), getArraySize(" lol this is ok[42] "));
|
||||
}
|
||||
|
||||
pub fn getTypeWithoutArrayNotation(typ: []const u8) []const u8 {
|
||||
if (std.mem.indexOf(u8, typ, "[")) |open| {
|
||||
return typ[0..open];
|
||||
}
|
||||
return typ;
|
||||
}
|
||||
|
||||
fn toZig(allocator: Allocator, c: []const u8) ![]const u8 {
|
||||
if (fixedMapping.get(c)) |fixed| {
|
||||
return fixed;
|
||||
}
|
||||
|
||||
const consT = if (isConst(c)) "const " else "";
|
||||
const pointeR = if (isPointer(c)) "?[*]" else "";
|
||||
const stripped = stripType(c);
|
||||
|
||||
const name = if (raylibToZigType.get(stripped)) |primitive| primitive else stripped;
|
||||
|
||||
if (isPointer(c)) {
|
||||
return try fmt(allocator, "{s}{s}{s}", .{ pointeR, consT, name });
|
||||
}
|
||||
return name;
|
||||
}
|
||||
test "toZig" {
|
||||
var arena = std.heap.ArenaAllocator.init(talloc);
|
||||
defer arena.deinit();
|
||||
const a = arena.allocator();
|
||||
|
||||
try expectEqualStrings("i32", try toZig(a, "int"));
|
||||
try expectEqualStrings("const i32", try toZig(a, "const int"));
|
||||
try expectEqualStrings("?[*]Vector2", try toZig(a, "Vector2 *"));
|
||||
}
|
||||
|
||||
const raylibToZigType = std.ComptimeStringMap([]const u8, .{
|
||||
.{ "void", "void" },
|
||||
.{ "bool", "bool" },
|
||||
.{ "char", "u8" },
|
||||
.{ "unsigned char", "u8" },
|
||||
.{ "short", "i16" },
|
||||
.{ "unsigned short", "u16" },
|
||||
.{ "int", "i32" },
|
||||
.{ "unsigned int", "u32" },
|
||||
.{ "long", "i64" },
|
||||
.{ "unsigned long", "u64" },
|
||||
.{ "unsigned long long", "u64" },
|
||||
.{ "float", "f32" },
|
||||
.{ "double", "f64" },
|
||||
});
|
||||
|
||||
const fixedMapping = std.ComptimeStringMap([]const u8, .{
|
||||
.{ "void *", "*anyopaque" },
|
||||
.{ "const void *", "*const anyopaque" },
|
||||
.{ "const unsigned char *", "[*:0]const u8" },
|
||||
.{ "const char *", "[*:0]const u8" },
|
||||
.{ "const char **", "[*]const [*:0]const u8" },
|
||||
.{ "char **", "[*][*:0]u8" },
|
||||
.{ "rAudioBuffer *", "*anyopaque" },
|
||||
.{ "rAudioProcessor *", "*anyopaque" },
|
||||
.{ "Image *", "*Image" },
|
||||
});
|
||||
|
||||
//--- Raylib parser JSONs -------------------------------------------------------------------------
|
||||
|
||||
const alias = std.ComptimeStringMap([]const u8, .{
|
||||
.{ "Camera", "Camera3D" },
|
||||
.{ "Texture", "Texture2D" },
|
||||
.{ "TextureCubemap", "Texture2D" },
|
||||
.{ "RenderTexture", "RenderTexture2D" },
|
||||
.{ "GuiStyle", "u32" },
|
||||
.{ "Quaternion", "Vector4" },
|
||||
.{ "PhysicsBody", "*PhysicsBodyData" },
|
||||
});
|
||||
|
||||
const cAlias = std.ComptimeStringMap([]const u8, .{
|
||||
.{ "Camera", "Camera3D" },
|
||||
.{ "Texture", "Texture2D" },
|
||||
.{ "TextureCubemap", "Texture2D" },
|
||||
.{ "RenderTexture", "RenderTexture2D" },
|
||||
.{ "Quaternion", "Vector4" },
|
||||
.{ "PhysicsBody", "PhysicsBodyData *" },
|
||||
});
|
||||
|
||||
pub const CombinedRaylib = struct {
|
||||
structs: std.StringArrayHashMap(RaylibStruct),
|
||||
enums: std.StringArrayHashMap(RaylibEnum),
|
||||
defines: std.StringArrayHashMap(RaylibDefine),
|
||||
functions: std.StringArrayHashMap(RaylibFunction),
|
||||
|
||||
pub fn load(allocator: Allocator, jsonFiles: []const []const u8) !@This() {
|
||||
var structs = std.StringArrayHashMap(RaylibStruct).init(allocator);
|
||||
var enums = std.StringArrayHashMap(RaylibEnum).init(allocator);
|
||||
var defines = std.StringArrayHashMap(RaylibDefine).init(allocator);
|
||||
var functions = std.StringArrayHashMap(RaylibFunction).init(allocator);
|
||||
|
||||
for (jsonFiles) |jsonFile| {
|
||||
std.log.info("parsing {s}", .{jsonFile});
|
||||
const jsonData = try std.fs.cwd().readFileAlloc(allocator, jsonFile, memoryConstrain);
|
||||
|
||||
const bindingJson = try json.parseFromSliceLeaky(RaylibJson, allocator, jsonData, .{
|
||||
.ignore_unknown_fields = true,
|
||||
.duplicate_field_behavior = .use_last,
|
||||
});
|
||||
|
||||
for (bindingJson.structs) |*s| {
|
||||
for (s.fields) |*f| {
|
||||
f.type = cAlias.get(f.type) orelse f.type;
|
||||
}
|
||||
try structs.put(s.name, s.*);
|
||||
}
|
||||
|
||||
for (bindingJson.enums) |e| {
|
||||
try enums.put(e.name, e);
|
||||
}
|
||||
|
||||
for (bindingJson.defines) |d| {
|
||||
try defines.put(d.name, d);
|
||||
}
|
||||
|
||||
for (bindingJson.functions) |*f| {
|
||||
f.returnType = cAlias.get(f.returnType) orelse f.returnType;
|
||||
if (f.params) |params| {
|
||||
for (params) |*p| {
|
||||
p.type = cAlias.get(p.type) orelse p.type;
|
||||
}
|
||||
}
|
||||
try functions.put(f.name, f.*);
|
||||
}
|
||||
}
|
||||
|
||||
return @This(){
|
||||
.structs = structs,
|
||||
.enums = enums,
|
||||
.defines = defines,
|
||||
.functions = functions,
|
||||
};
|
||||
}
|
||||
|
||||
pub fn toIntermediate(self: @This(), allocator: Allocator, customs: Intermediate) !Intermediate {
|
||||
var functions = std.ArrayList(Function).init(allocator);
|
||||
var enums = std.ArrayList(Enum).init(allocator);
|
||||
var structs = std.ArrayList(Struct).init(allocator);
|
||||
|
||||
enums: for (self.enums.values()) |e| {
|
||||
for (customs.enums) |tt| {
|
||||
if (eql(tt.name, e.name)) break :enums;
|
||||
}
|
||||
try enums.append(try parseRaylibEnum(allocator, e));
|
||||
}
|
||||
structs: for (self.structs.values()) |s| {
|
||||
for (customs.structs) |tt| {
|
||||
if (eql(tt.name, s.name)) break :structs;
|
||||
}
|
||||
try structs.append(try parseRaylibStruct(allocator, s, customs));
|
||||
}
|
||||
for (self.defines.values()) |_| {}
|
||||
|
||||
funcs: for (self.functions.values()) |f| {
|
||||
for (customs.functions) |ff| {
|
||||
if (eql(ff.name, f.name)) break :funcs;
|
||||
}
|
||||
try functions.append(try parseRaylibFunction(allocator, f, customs.types));
|
||||
}
|
||||
|
||||
return Intermediate{
|
||||
.functions = try functions.toOwnedSlice(),
|
||||
.enums = try enums.toOwnedSlice(),
|
||||
.structs = try structs.toOwnedSlice(),
|
||||
};
|
||||
}
|
||||
|
||||
fn containsStruct(self: @This(), name: []const u8) bool {
|
||||
return self.structs.contains(name);
|
||||
}
|
||||
|
||||
fn containsEnum(self: @This(), name: []const u8) bool {
|
||||
return self.enums.contains(name);
|
||||
}
|
||||
|
||||
fn containsFunction(self: @This(), name: []const u8) bool {
|
||||
return self.functions.contains(name);
|
||||
}
|
||||
};
|
||||
|
||||
const RaylibJson = struct {
|
||||
structs: []RaylibStruct,
|
||||
enums: []RaylibEnum,
|
||||
defines: []RaylibDefine,
|
||||
functions: []RaylibFunction,
|
||||
};
|
||||
|
||||
pub const RaylibStruct = struct {
|
||||
name: []const u8,
|
||||
description: []const u8,
|
||||
fields: []RaylibField,
|
||||
};
|
||||
|
||||
pub const RaylibField = struct {
|
||||
name: []const u8,
|
||||
description: []const u8,
|
||||
type: []const u8,
|
||||
};
|
||||
|
||||
pub const RaylibEnum = struct {
|
||||
name: []const u8,
|
||||
description: []const u8,
|
||||
values: []RaylibEnumValue,
|
||||
};
|
||||
|
||||
pub const RaylibEnumValue = struct {
|
||||
name: []const u8,
|
||||
description: []const u8,
|
||||
value: c_int,
|
||||
};
|
||||
|
||||
pub const RaylibFunction = struct {
|
||||
name: []const u8,
|
||||
description: []const u8,
|
||||
returnType: []const u8,
|
||||
params: ?[]RaylibFunctionParam = null,
|
||||
};
|
||||
|
||||
pub const RaylibFunctionParam = struct {
|
||||
name: []const u8,
|
||||
type: []const u8,
|
||||
description: ?[]const u8 = null,
|
||||
};
|
||||
|
||||
pub const RaylibDefine = struct {
|
||||
name: []const u8,
|
||||
type: []const u8,
|
||||
value: []const u8,
|
||||
description: ?[]const u8 = null,
|
||||
};
|
||||
|
||||
//--- Helpers -------------------------------------------------------------------------------------
|
||||
|
||||
/// true if C type is primitive or a pointer to anything
|
||||
/// this means we don't need to wrap it in a pointer
|
||||
pub fn isPrimitiveOrPointer(c: []const u8) bool {
|
||||
const primitiveTypes = std.ComptimeStringMap(void, .{
|
||||
.{ "void", {} },
|
||||
.{ "bool", {} },
|
||||
.{ "char", {} },
|
||||
.{ "unsigned char", {} },
|
||||
.{ "short", {} },
|
||||
.{ "unsigned short", {} },
|
||||
.{ "int", {} },
|
||||
.{ "unsigned int", {} },
|
||||
.{ "long", {} },
|
||||
.{ "unsigned long", {} },
|
||||
.{ "unsigned long long", {} },
|
||||
.{ "float", {} },
|
||||
.{ "double", {} },
|
||||
});
|
||||
return primitiveTypes.has(stripType(c)) or endsWith(c, "*");
|
||||
}
|
||||
|
||||
fn eql(a: []const u8, b: []const u8) bool {
|
||||
return std.mem.eql(u8, a, b);
|
||||
}
|
||||
|
||||
fn startsWith(haystack: []const u8, needle: []const u8) bool {
|
||||
return std.mem.startsWith(u8, haystack, needle);
|
||||
}
|
||||
|
||||
fn endsWith(haystack: []const u8, needle: []const u8) bool {
|
||||
return std.mem.endsWith(u8, haystack, needle);
|
||||
}
|
||||
Loading…
Reference in New Issue
Block a user