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

Replace tabs with spaces and update year of copyright notices (#927)

Browse source 
* Update year of copyright notices

* Fix mistake in comment

* Fix typo ("algorythms")

* Replace tabs with spaces

* Remove trailing whitespace and fix mistake in comment

* Fix ExportImageAsCode missing comment rectangle corner

* Replace tab with spaces

* Replace tabs with spaces
This commit is contained in:
Leandro Gabriel 2019-08-03 06:07:41 -03:00 • committed by Ray
parent 68ffbc06c7
commit 89c16baf18
25 changed files with 791 additions and 790 deletions
Download patch file Download diff file Expand all files Collapse all files

64
examples/core/core_basic_window.cpp
View file

@ -23,40 +23,40 @@
int main(int argc, char* argv[]) int main(int argc, char* argv[])
{ {
// Initialization // Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window"); InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
SetTargetFPS(60); SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// TODO: Update your variables here
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; // Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// TODO: Update your variables here
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(RAYWHITE);
DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
} }

310
examples/network/network_ping_pong.c
View file

@ -48,178 +48,178 @@ char recvBuffer[512];
// Attempt to connect to the network (Either TCP, or UDP) // Attempt to connect to the network (Either TCP, or UDP)
void NetworkConnect() void NetworkConnect()
{ {
// If the server is configured as UDP, ignore connection requests // If the server is configured as UDP, ignore connection requests
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
ping = true; ping = true;
connected = true; connected = true;
} else { } else {
// If the client is connected, run the server code to check for a connection // If the client is connected, run the server code to check for a connection
if (client_connected) { if (client_connected) {
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
if (active > 0) { if (active > 0) {
if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) { if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) {
AddSocket(socket_set, connection); AddSocket(socket_set, connection);
ping = true; ping = true;
connected = true; connected = true;
} }
} }
} else { } else {
// Check if we're connected every _delay_ seconds // Check if we're connected every _delay_ seconds
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (IsSocketConnected(client_res->socket)) { if (IsSocketConnected(client_res->socket)) {
client_connected = true; client_connected = true;
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
} }
} }
// Once connected to the network, check the sockets for pending information // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong. // and when information is ready, send either a Ping or a Pong.
void NetworkUpdate() void NetworkUpdate()
{ {
// CheckSockets // CheckSockets
// //
// If any of the sockets in the socket_set are pending (received data, or requests) // If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) // then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
// IsSocketReady // IsSocketReady
// //
// If the socket is ready, attempt to receive data from the socket // If the socket is ready, attempt to receive data from the socket
int bytesRecv = 0; int bytesRecv = 0;
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
if (IsSocketReady(client_res->socket)) { if (IsSocketReady(client_res->socket)) {
bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen); bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen);
} }
if (IsSocketReady(server_res->socket)) { if (IsSocketReady(server_res->socket)) {
bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen); bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
} }
} else { } else {
if (IsSocketReady(connection)) { if (IsSocketReady(connection)) {
bytesRecv = SocketReceive(connection, recvBuffer, msglen); bytesRecv = SocketReceive(connection, recvBuffer, msglen);
} }
} }
// If we received data, was that data a "Ping!" or a "Pong!" // If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) { if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
} }
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (ping) { if (ping) {
ping = false; ping = false;
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
SocketSend(client_res->socket, pingmsg, msglen); SocketSend(client_res->socket, pingmsg, msglen);
} else { } else {
SocketSend(client_res->socket, pingmsg, msglen); SocketSend(client_res->socket, pingmsg, msglen);
} }
} else if (pong) { } else if (pong) {
pong = false; pong = false;
if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) { if (server_cfg.type == SOCKET_UDP && client_cfg.type == SOCKET_UDP) {
SocketSend(client_res->socket, pongmsg, msglen); SocketSend(client_res->socket, pongmsg, msglen);
} else { } else {
SocketSend(client_res->socket, pongmsg, msglen); SocketSend(client_res->socket, pongmsg, msglen);
} }
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
int main() int main()
{ {
// Setup // Setup
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - ping pong"); screenWidth, screenHeight, "raylib [network] example - ping pong");
SetTargetFPS(60); SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG); SetTraceLogLevel(LOG_DEBUG);
// Networking // Networking
InitNetwork(); InitNetwork();
// Create the server // Create the server
// //
// Performs // Performs
// getaddrinfo // getaddrinfo
// socket // socket
// setsockopt // setsockopt
// bind // bind
// listen // listen
server_res = AllocSocketResult(); server_res = AllocSocketResult();
if (!SocketCreate(&server_cfg, server_res)) { if (!SocketCreate(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} else { } else {
if (!SocketBind(&server_cfg, server_res)) { if (!SocketBind(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} else { } else {
if (!(server_cfg.type == SOCKET_UDP)) { if (!(server_cfg.type == SOCKET_UDP)) {
if (!SocketListen(&server_cfg, server_res)) { if (!SocketListen(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, TraceLog(LOG_WARNING,
"Failed to start listen server: status %d, errno %d", "Failed to start listen server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} }
} }
} }
} }
// Create the client // Create the client
// //
// Performs // Performs
// getaddrinfo // getaddrinfo
// socket // socket
// setsockopt // setsockopt
// connect (TCP only) // connect (TCP only)
client_res = AllocSocketResult(); client_res = AllocSocketResult();
if (!SocketCreate(&client_cfg, client_res)) { if (!SocketCreate(&client_cfg, client_res)) {
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d",
client_res->status, client_res->socket->status); client_res->status, client_res->socket->status);
} else { } else {
if (!(client_cfg.type == SOCKET_UDP)) { if (!(client_cfg.type == SOCKET_UDP)) {
if (!SocketConnect(&client_cfg, client_res)) { if (!SocketConnect(&client_cfg, client_res)) {
TraceLog(LOG_WARNING, TraceLog(LOG_WARNING,
"Failed to connect to server: status %d, errno %d", "Failed to connect to server: status %d, errno %d",
client_res->status, client_res->socket->status); client_res->status, client_res->socket->status);
} }
} }
} }
// Create & Add sockets to the socket set // Create & Add sockets to the socket set
socket_set = AllocSocketSet(3); socket_set = AllocSocketSet(3);
msglen = strlen(pingmsg) + 1; msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer)); memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, server_res->socket); AddSocket(socket_set, server_res->socket);
AddSocket(socket_set, client_res->socket); AddSocket(socket_set, client_res->socket);
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) { if (connected) {
NetworkUpdate(); NetworkUpdate();
} else { } else {
NetworkConnect(); NetworkConnect();
} }
EndDrawing(); EndDrawing();
} }
// Cleanup // Cleanup
CloseWindow(); CloseWindow();
return 0; return 0;
} }

46
examples/network/network_resolve_host.c
View file

@ -28,20 +28,20 @@ uint16_t port = 0;
int main() int main()
{ {
// Setup // Setup
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - ping pong"); screenWidth, screenHeight, "raylib [network] example - ping pong");
SetTargetFPS(60); SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG); SetTraceLogLevel(LOG_DEBUG);
// Networking // Networking
InitNetwork(); InitNetwork();
AddressInformation* addr = AllocAddressList(1); AddressInformation* addr = AllocAddressList(1);
int count = ResolveHost( int count = ResolveHost(
NULL, NULL,
"5210", "5210",
ADDRESS_TYPE_IPV4, ADDRESS_TYPE_IPV4,
@ -61,20 +61,20 @@ int main()
TraceLog(LOG_INFO, "Resolved to ip %s::%d\n", buffer, port); TraceLog(LOG_INFO, "Resolved to ip %s::%d\n", buffer, port);
} }
// Main game loop // Main game loop
while (!WindowShouldClose()) while (!WindowShouldClose())
{ {
// Draw // Draw
BeginDrawing(); BeginDrawing();
// Clear // Clear
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// End draw // End draw
EndDrawing(); EndDrawing();
} }
// Cleanup // Cleanup
CloseWindow(); CloseWindow();
return 0; return 0;
} }

174
examples/network/network_tcp_client.c
View file

@ -43,109 +43,109 @@ char recvBuffer[512];
// Attempt to connect to the network (Either TCP, or UDP) // Attempt to connect to the network (Either TCP, or UDP)
void NetworkConnect() void NetworkConnect()
{ {
// Check if we're connected every _delay_ seconds // Check if we're connected every _delay_ seconds
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (IsSocketConnected(client_res->socket)) { connected = true; } if (IsSocketConnected(client_res->socket)) { connected = true; }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
// Once connected to the network, check the sockets for pending information // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong. // and when information is ready, send either a Ping or a Pong.
void NetworkUpdate() void NetworkUpdate()
{ {
// CheckSockets // CheckSockets
// //
// If any of the sockets in the socket_set are pending (received data, or requests) // If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) // then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
// IsSocketReady // IsSocketReady
// //
// If the socket is ready, attempt to receive data from the socket // If the socket is ready, attempt to receive data from the socket
int bytesRecv = 0; int bytesRecv = 0;
if (IsSocketReady(client_res->socket)) { if (IsSocketReady(client_res->socket)) {
bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen); bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen);
} }
// If we received data, was that data a "Ping!" or a "Pong!" // If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) { if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
} }
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (ping) { if (ping) {
ping = false; ping = false;
SocketSend(client_res->socket, pingmsg, msglen); SocketSend(client_res->socket, pingmsg, msglen);
} else if (pong) { } else if (pong) {
pong = false; pong = false;
SocketSend(client_res->socket, pongmsg, msglen); SocketSend(client_res->socket, pongmsg, msglen);
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
int main() int main()
{ {
// Setup // Setup
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - tcp client"); screenWidth, screenHeight, "raylib [network] example - tcp client");
SetTargetFPS(60); SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG); SetTraceLogLevel(LOG_DEBUG);
// Networking // Networking
InitNetwork(); InitNetwork();
// Create the client // Create the client
// //
// Performs // Performs
// getaddrinfo // getaddrinfo
// socket // socket
// setsockopt // setsockopt
// connect (TCP only) // connect (TCP only)
client_res = AllocSocketResult(); client_res = AllocSocketResult();
if (!SocketCreate(&client_cfg, client_res)) { if (!SocketCreate(&client_cfg, client_res)) {
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d",
client_res->status, client_res->socket->status); client_res->status, client_res->socket->status);
} else { } else {
if (!(client_cfg.type == SOCKET_UDP)) { if (!(client_cfg.type == SOCKET_UDP)) {
if (!SocketConnect(&client_cfg, client_res)) { if (!SocketConnect(&client_cfg, client_res)) {
TraceLog(LOG_WARNING, TraceLog(LOG_WARNING,
"Failed to connect to server: status %d, errno %d", "Failed to connect to server: status %d, errno %d",
client_res->status, client_res->socket->status); client_res->status, client_res->socket->status);
} }
} }
} }
// Create & Add sockets to the socket set // Create & Add sockets to the socket set
socket_set = AllocSocketSet(1); socket_set = AllocSocketSet(1);
msglen = strlen(pingmsg) + 1; msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer)); memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, client_res->socket); AddSocket(socket_set, client_res->socket);
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) { if (connected) {
NetworkUpdate(); NetworkUpdate();
} else { } else {
NetworkConnect(); NetworkConnect();
} }
EndDrawing(); EndDrawing();
} }
// Cleanup // Cleanup
CloseWindow(); CloseWindow();
return 0; return 0;
} }

198
examples/network/network_tcp_server.c
View file

@ -45,121 +45,121 @@ char recvBuffer[512];
// Attempt to connect to the network (Either TCP, or UDP) // Attempt to connect to the network (Either TCP, or UDP)
void NetworkConnect() void NetworkConnect()
{ {
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
if (active > 0) { if (active > 0) {
if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) { if ((connection = SocketAccept(server_res->socket, &connection_cfg)) != NULL) {
AddSocket(socket_set, connection); AddSocket(socket_set, connection);
ping = true; ping = true;
connected = true; connected = true;
} }
} }
} }
// Once connected to the network, check the sockets for pending information // Once connected to the network, check the sockets for pending information
// and when information is ready, send either a Ping or a Pong. // and when information is ready, send either a Ping or a Pong.
void NetworkUpdate() void NetworkUpdate()
{ {
// CheckSockets // CheckSockets
// //
// If any of the sockets in the socket_set are pending (received data, or requests) // If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) // then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
// IsSocketReady // IsSocketReady
// //
// If the socket is ready, attempt to receive data from the socket // If the socket is ready, attempt to receive data from the socket
int bytesRecv = 0; int bytesRecv = 0;
if (IsSocketReady(connection)) { if (IsSocketReady(connection)) {
bytesRecv = SocketReceive(connection, recvBuffer, msglen); bytesRecv = SocketReceive(connection, recvBuffer, msglen);
} }
// If we received data, was that data a "Ping!" or a "Pong!" // If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) { if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
} }
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (ping) { if (ping) {
ping = false; ping = false;
SocketSend(connection, pingmsg, msglen); SocketSend(connection, pingmsg, msglen);
} else if (pong) { } else if (pong) {
pong = false; pong = false;
SocketSend(connection, pongmsg, msglen); SocketSend(connection, pongmsg, msglen);
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
int main() int main()
{ {
// Setup // Setup
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - tcp server"); screenWidth, screenHeight, "raylib [network] example - tcp server");
SetTargetFPS(60); SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG); SetTraceLogLevel(LOG_DEBUG);
// Networking // Networking
InitNetwork(); InitNetwork();
// Create the server // Create the server
// //
// Performs // Performs
// getaddrinfo // getaddrinfo
// socket // socket
// setsockopt // setsockopt
// bind // bind
// listen // listen
server_res = AllocSocketResult(); server_res = AllocSocketResult();
if (!SocketCreate(&server_cfg, server_res)) { if (!SocketCreate(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} else { } else {
if (!SocketBind(&server_cfg, server_res)) { if (!SocketBind(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} else { } else {
if (!(server_cfg.type == SOCKET_UDP)) { if (!(server_cfg.type == SOCKET_UDP)) {
if (!SocketListen(&server_cfg, server_res)) { if (!SocketListen(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, TraceLog(LOG_WARNING,
"Failed to start listen server: status %d, errno %d", "Failed to start listen server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} }
} }
} }
} }
// Create & Add sockets to the socket set // Create & Add sockets to the socket set
socket_set = AllocSocketSet(2); socket_set = AllocSocketSet(2);
msglen = strlen(pingmsg) + 1; msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer)); memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, server_res->socket); AddSocket(socket_set, server_res->socket);
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
if (connected) { if (connected) {
NetworkUpdate(); NetworkUpdate();
} else { } else {
NetworkConnect(); NetworkConnect();
} }
EndDrawing(); EndDrawing();
} }
// Cleanup // Cleanup
CloseWindow(); CloseWindow();
return 0; return 0;
} }

146
examples/network/network_test.c
View file

@ -27,80 +27,80 @@
void test_network_initialise() void test_network_initialise()
{ {
assert(InitNetwork() == true); assert(InitNetwork() == true);
} }
void test_socket_result() void test_socket_result()
{ {
SocketResult *result = AllocSocketResult(); SocketResult *result = AllocSocketResult();
assert(result != NULL); assert(result != NULL);
FreeSocketResult(&result); FreeSocketResult(&result);
assert(result == NULL); assert(result == NULL);
} }
void test_socket() void test_socket()
{ {
Socket *socket = AllocSocket(); Socket *socket = AllocSocket();
assert(socket != NULL); assert(socket != NULL);
FreeSocket(&socket); FreeSocket(&socket);
assert(socket == NULL); assert(socket == NULL);
} }
void test_resolve_ip() void test_resolve_ip()
{ {
const char *host = "8.8.8.8"; const char *host = "8.8.8.8";
const char *port = "8080"; const char *port = "8080";
char ip[ADDRESS_IPV6_ADDRSTRLEN]; char ip[ADDRESS_IPV6_ADDRSTRLEN];
char service[ADDRESS_MAXSERV]; char service[ADDRESS_MAXSERV];
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_NUMERICHOST, ip, service); ResolveIP(host, port, NAME_INFO_NUMERICHOST, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "8.8.8.8") == 0); assert(strcmp(ip, "8.8.8.8") == 0);
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_DEFAULT, ip, service); ResolveIP(host, port, NAME_INFO_DEFAULT, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "google-public-dns-a.google.com") == 0); assert(strcmp(ip, "google-public-dns-a.google.com") == 0);
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_NOFQDN, ip, service); ResolveIP(host, port, NAME_INFO_NOFQDN, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "google-public-dns-a") == 0); assert(strcmp(ip, "google-public-dns-a") == 0);
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_NUMERICHOST, ip, service); ResolveIP(host, port, NAME_INFO_NUMERICHOST, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "8.8.8.8") == 0); assert(strcmp(ip, "8.8.8.8") == 0);
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_NAMEREQD, ip, service); ResolveIP(host, port, NAME_INFO_NAMEREQD, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "google-public-dns-a.google.com") == 0); assert(strcmp(ip, "google-public-dns-a.google.com") == 0);
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_NUMERICSERV, ip, service); ResolveIP(host, port, NAME_INFO_NUMERICSERV, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "google-public-dns-a.google.com") == 0); assert(strcmp(ip, "google-public-dns-a.google.com") == 0);
memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN); memset(ip, '\0', ADDRESS_IPV6_ADDRSTRLEN);
ResolveIP(host, port, NAME_INFO_DGRAM, ip, service); ResolveIP(host, port, NAME_INFO_DGRAM, ip, service);
TraceLog(LOG_INFO, "Resolved %s to %s", host, ip); TraceLog(LOG_INFO, "Resolved %s to %s", host, ip);
assert(strcmp(ip, "google-public-dns-a.google.com") == 0); assert(strcmp(ip, "google-public-dns-a.google.com") == 0);
} }
void test_resolve_host() void test_resolve_host()
{ {
const char * address = "localhost"; const char * address = "localhost";
const char * port = "80"; const char * port = "80";
AddressInformation *addr = AllocAddressList(3); AddressInformation *addr = AllocAddressList(3);
int count = ResolveHost(address, port, ADDRESS_TYPE_ANY, 0, addr); int count = ResolveHost(address, port, ADDRESS_TYPE_ANY, 0, addr);
assert(GetAddressFamily(addr[0]) == ADDRESS_TYPE_IPV6); assert(GetAddressFamily(addr[0]) == ADDRESS_TYPE_IPV6);
assert(GetAddressFamily(addr[1]) == ADDRESS_TYPE_IPV4); assert(GetAddressFamily(addr[1]) == ADDRESS_TYPE_IPV4);
assert(GetAddressSocketType(addr[0]) == 0); assert(GetAddressSocketType(addr[0]) == 0);
assert(GetAddressProtocol(addr[0]) == 0); assert(GetAddressProtocol(addr[0]) == 0);
// for (size_t i = 0; i < count; i++) { PrintAddressInfo(addr[i]); } // for (size_t i = 0; i < count; i++) { PrintAddressInfo(addr[i]); }
} }
void test_address() void test_address()
@ -113,36 +113,36 @@ void test_address_list()
void test_socket_create() void test_socket_create()
{ {
SocketConfig server_cfg = {.host = "127.0.0.1", .port = "8080", .server = true, .nonblocking = true}; SocketConfig server_cfg = {.host = "127.0.0.1", .port = "8080", .server = true, .nonblocking = true};
Socket * socket = AllocSocket(); Socket * socket = AllocSocket();
SocketResult *server_res = AllocSocketResult(); SocketResult *server_res = AllocSocketResult();
SocketSet * socket_set = AllocSocketSet(1); SocketSet * socket_set = AllocSocketSet(1);
assert(SocketCreate(&server_cfg, server_res)); assert(SocketCreate(&server_cfg, server_res));
assert(AddSocket(socket_set, server_res->socket)); assert(AddSocket(socket_set, server_res->socket));
assert(SocketListen(&server_cfg, server_res)); assert(SocketListen(&server_cfg, server_res));
} }
int main() int main()
{ {
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - network test"); screenWidth, screenHeight, "raylib [network] example - network test");
SetTargetFPS(60); SetTargetFPS(60);
// Run the tests // Run the tests
test_network_initialise(); test_network_initialise();
test_resolve_host(); test_resolve_host();
// test_socket_create(); // test_socket_create();
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY); DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY);
EndDrawing(); EndDrawing();
} }
CloseWindow(); CloseWindow();
return 0; return 0;
} }

140
examples/network/network_udp_client.c
View file

@ -43,86 +43,86 @@ char recvBuffer[512];
// and when information is ready, send either a Ping or a Pong. // and when information is ready, send either a Ping or a Pong.
void NetworkUpdate() void NetworkUpdate()
{ {
// CheckSockets // CheckSockets
// //
// If any of the sockets in the socket_set are pending (received data, or requests) // If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) // then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
// IsSocketReady // IsSocketReady
// //
// If the socket is ready, attempt to receive data from the socket // If the socket is ready, attempt to receive data from the socket
int bytesRecv = 0; int bytesRecv = 0;
if (IsSocketReady(client_res->socket)) { if (IsSocketReady(client_res->socket)) {
bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen); bytesRecv = SocketReceive(client_res->socket, recvBuffer, msglen);
} }
// If we received data, was that data a "Ping!" or a "Pong!" // If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) { if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
} }
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (ping) { if (ping) {
ping = false; ping = false;
SocketSend(client_res->socket, pingmsg, msglen); SocketSend(client_res->socket, pingmsg, msglen);
} else if (pong) { } else if (pong) {
pong = false; pong = false;
SocketSend(client_res->socket, pongmsg, msglen); SocketSend(client_res->socket, pongmsg, msglen);
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
int main() int main()
{ {
// Setup // Setup
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - udp client"); screenWidth, screenHeight, "raylib [network] example - udp client");
SetTargetFPS(60); SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG); SetTraceLogLevel(LOG_DEBUG);
// Networking // Networking
InitNetwork(); InitNetwork();
// Create the client // Create the client
// //
// Performs // Performs
// getaddrinfo // getaddrinfo
// socket // socket
// setsockopt // setsockopt
// connect (TCP only) // connect (TCP only)
client_res = AllocSocketResult(); client_res = AllocSocketResult();
if (!SocketCreate(&client_cfg, client_res)) { if (!SocketCreate(&client_cfg, client_res)) {
TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to open client: status %d, errno %d",
client_res->status, client_res->socket->status); client_res->status, client_res->socket->status);
} }
// Create & Add sockets to the socket set // Create & Add sockets to the socket set
socket_set = AllocSocketSet(1); socket_set = AllocSocketSet(1);
msglen = strlen(pingmsg) + 1; msglen = strlen(pingmsg) + 1;
ping = true; ping = true;
memset(recvBuffer, '\0', sizeof(recvBuffer)); memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, client_res->socket); AddSocket(socket_set, client_res->socket);
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
NetworkUpdate(); NetworkUpdate();
EndDrawing(); EndDrawing();
} }
// Cleanup // Cleanup
CloseWindow(); CloseWindow();
return 0; return 0;
} }

152
examples/network/network_udp_server.c
View file

@ -43,92 +43,92 @@ char recvBuffer[512];
// and when information is ready, send either a Ping or a Pong. // and when information is ready, send either a Ping or a Pong.
void NetworkUpdate() void NetworkUpdate()
{ {
// CheckSockets // CheckSockets
// //
// If any of the sockets in the socket_set are pending (received data, or requests) // If any of the sockets in the socket_set are pending (received data, or requests)
// then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) // then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket)
int active = CheckSockets(socket_set, 0); int active = CheckSockets(socket_set, 0);
if (active != 0) { if (active != 0) {
TraceLog(LOG_DEBUG, TraceLog(LOG_DEBUG,
"There are currently %d socket(s) with data to be processed.", active); "There are currently %d socket(s) with data to be processed.", active);
} }
// IsSocketReady // IsSocketReady
// //
// If the socket is ready, attempt to receive data from the socket // If the socket is ready, attempt to receive data from the socket
// int bytesRecv = 0; // int bytesRecv = 0;
// if (IsSocketReady(server_res->socket)) { // if (IsSocketReady(server_res->socket)) {
// bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen); // bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
// } // }
int bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen); int bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen);
// If we received data, was that data a "Ping!" or a "Pong!" // If we received data, was that data a "Ping!" or a "Pong!"
if (bytesRecv > 0) { if (bytesRecv > 0) {
if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; }
if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; }
} }
// After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa
elapsed += GetFrameTime(); elapsed += GetFrameTime();
if (elapsed > delay) { if (elapsed > delay) {
if (ping) { if (ping) {
ping = false; ping = false;
SocketSend(server_res->socket, pingmsg, msglen); SocketSend(server_res->socket, pingmsg, msglen);
} else if (pong) { } else if (pong) {
pong = false; pong = false;
SocketSend(server_res->socket, pongmsg, msglen); SocketSend(server_res->socket, pongmsg, msglen);
} }
elapsed = 0.0f; elapsed = 0.0f;
} }
} }
int main() int main()
{ {
// Setup // Setup
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow( InitWindow(
screenWidth, screenHeight, "raylib [network] example - udp server"); screenWidth, screenHeight, "raylib [network] example - udp server");
SetTargetFPS(60); SetTargetFPS(60);
SetTraceLogLevel(LOG_DEBUG); SetTraceLogLevel(LOG_DEBUG);
// Networking // Networking
InitNetwork(); InitNetwork();
// Create the server // Create the server
// //
// Performs // Performs
// getaddrinfo // getaddrinfo
// socket // socket
// setsockopt // setsockopt
// bind // bind
// listen // listen
server_res = AllocSocketResult(); server_res = AllocSocketResult();
if (!SocketCreate(&server_cfg, server_res)) { if (!SocketCreate(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to open server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} else { } else {
if (!SocketBind(&server_cfg, server_res)) { if (!SocketBind(&server_cfg, server_res)) {
TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d", TraceLog(LOG_WARNING, "Failed to bind server: status %d, errno %d",
server_res->status, server_res->socket->status); server_res->status, server_res->socket->status);
} }
} }
// Create & Add sockets to the socket set // Create & Add sockets to the socket set
socket_set = AllocSocketSet(1); socket_set = AllocSocketSet(1);
msglen = strlen(pingmsg) + 1; msglen = strlen(pingmsg) + 1;
memset(recvBuffer, '\0', sizeof(recvBuffer)); memset(recvBuffer, '\0', sizeof(recvBuffer));
AddSocket(socket_set, server_res->socket); AddSocket(socket_set, server_res->socket);
// Main game loop // Main game loop
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
NetworkUpdate(); NetworkUpdate();
EndDrawing(); EndDrawing();
} }
// Cleanup // Cleanup
CloseWindow(); CloseWindow();
return 0; return 0;
} }

36
examples/others/raudio_standalone.c
View file

@ -58,29 +58,29 @@
// Check if a key has been pressed // Check if a key has been pressed
static int kbhit(void) static int kbhit(void)
{ {
struct termios oldt, newt; struct termios oldt, newt;
int ch; int ch;
int oldf; int oldf;
tcgetattr(STDIN_FILENO, &oldt); tcgetattr(STDIN_FILENO, &oldt);
newt = oldt; newt = oldt;
newt.c_lflag &= ~(ICANON | ECHO); newt.c_lflag &= ~(ICANON | ECHO);
tcsetattr(STDIN_FILENO, TCSANOW, &newt); tcsetattr(STDIN_FILENO, TCSANOW, &newt);
oldf = fcntl(STDIN_FILENO, F_GETFL, 0); oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK); fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);
ch = getchar(); ch = getchar();
tcsetattr(STDIN_FILENO, TCSANOW, &oldt); tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
fcntl(STDIN_FILENO, F_SETFL, oldf); fcntl(STDIN_FILENO, F_SETFL, oldf);
if (ch != EOF) if (ch != EOF)
{ {
ungetc(ch, stdin); ungetc(ch, stdin);
return 1; return 1;
} }
return 0; return 0;
} }
// Get pressed character // Get pressed character

56
examples/shaders/shaders_texture_waves.c
View file

@ -33,38 +33,38 @@ int main(void)
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - texture waves"); InitWindow(screenWidth, screenHeight, "raylib [shaders] example - texture waves");
// Load texture texture to apply shaders // Load texture texture to apply shaders
Texture2D texture = LoadTexture("resources/space.png"); Texture2D texture = LoadTexture("resources/space.png");
// Load shader and setup location points and values // Load shader and setup location points and values
Shader shader = LoadShader(0, FormatText("resources/shaders/glsl%i/wave.fs", GLSL_VERSION)); Shader shader = LoadShader(0, FormatText("resources/shaders/glsl%i/wave.fs", GLSL_VERSION));
int secondsLoc = GetShaderLocation(shader, "secondes"); int secondsLoc = GetShaderLocation(shader, "secondes");
int freqXLoc = GetShaderLocation(shader, "freqX"); int freqXLoc = GetShaderLocation(shader, "freqX");
int freqYLoc = GetShaderLocation(shader, "freqY"); int freqYLoc = GetShaderLocation(shader, "freqY");
int ampXLoc = GetShaderLocation(shader, "ampX"); int ampXLoc = GetShaderLocation(shader, "ampX");
int ampYLoc = GetShaderLocation(shader, "ampY"); int ampYLoc = GetShaderLocation(shader, "ampY");
int speedXLoc = GetShaderLocation(shader, "speedX"); int speedXLoc = GetShaderLocation(shader, "speedX");
int speedYLoc = GetShaderLocation(shader, "speedY"); int speedYLoc = GetShaderLocation(shader, "speedY");
// Shader uniform values that can be updated at any time // Shader uniform values that can be updated at any time
float freqX = 25.0f; float freqX = 25.0f;
float freqY = 25.0f; float freqY = 25.0f;
float ampX = 5.0f; float ampX = 5.0f;
float ampY = 5.0f; float ampY = 5.0f;
float speedX = 8.0f; float speedX = 8.0f;
float speedY = 8.0f; float speedY = 8.0f;
float screenSize[2] = { (float)GetScreenWidth(), (float)GetScreenHeight() }; float screenSize[2] = { (float)GetScreenWidth(), (float)GetScreenHeight() };
SetShaderValue(shader, GetShaderLocation(shader, "size"), &screenSize, UNIFORM_VEC2); SetShaderValue(shader, GetShaderLocation(shader, "size"), &screenSize, UNIFORM_VEC2);
SetShaderValue(shader, freqXLoc, &freqX, UNIFORM_FLOAT); SetShaderValue(shader, freqXLoc, &freqX, UNIFORM_FLOAT);
SetShaderValue(shader, freqYLoc, &freqY, UNIFORM_FLOAT); SetShaderValue(shader, freqYLoc, &freqY, UNIFORM_FLOAT);
SetShaderValue(shader, ampXLoc, &ampX, UNIFORM_FLOAT); SetShaderValue(shader, ampXLoc, &ampX, UNIFORM_FLOAT);
SetShaderValue(shader, ampYLoc, &ampY, UNIFORM_FLOAT); SetShaderValue(shader, ampYLoc, &ampY, UNIFORM_FLOAT);
SetShaderValue(shader, speedXLoc, &speedX, UNIFORM_FLOAT); SetShaderValue(shader, speedXLoc, &speedX, UNIFORM_FLOAT);
SetShaderValue(shader, speedYLoc, &speedY, UNIFORM_FLOAT); SetShaderValue(shader, speedYLoc, &speedY, UNIFORM_FLOAT);
float seconds = 0.0f; float seconds = 0.0f;
@ -76,9 +76,9 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
seconds += GetFrameTime(); seconds += GetFrameTime();
SetShaderValue(shader, secondsLoc, &seconds, UNIFORM_FLOAT); SetShaderValue(shader, secondsLoc, &seconds, UNIFORM_FLOAT);
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -87,12 +87,12 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginShaderMode(shader); BeginShaderMode(shader);
DrawTexture(texture, 0, 0, WHITE); DrawTexture(texture, 0, 0, WHITE);
DrawTexture(texture, texture.width, 0, WHITE); DrawTexture(texture, texture.width, 0, WHITE);
EndShaderMode(); EndShaderMode();
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------

4
games/just_do/just_do.c
View file

@ -50,8 +50,8 @@ void UpdateDrawFrame(void); // Update and Draw one frame
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
int main(void) int main(void)
{ {
// Initialization (Note windowTitle is unused on Android) // Initialization (Note windowTitle is unused on Android)
//--------------------------------------------------------- //---------------------------------------------------------
InitWindow(screenWidth, screenHeight, "JUST DO [GGJ15]"); InitWindow(screenWidth, screenHeight, "JUST DO [GGJ15]");
// Load global data here (assets that must be available in all screens, i.e. fonts) // Load global data here (assets that must be available in all screens, i.e. fonts)

4
games/koala_seasons/koala_seasons.c
View file

@ -48,8 +48,8 @@ void UpdateDrawFrame(void); // Update and Draw one frame
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
int main(void) int main(void)
{ {
// Initialization (Note windowTitle is unused on Android) // Initialization (Note windowTitle is unused on Android)
//--------------------------------------------------------- //---------------------------------------------------------
InitWindow(screenWidth, screenHeight, "KOALA SEASONS"); InitWindow(screenWidth, screenHeight, "KOALA SEASONS");
// Load global data here (assets that must be available in all screens, i.e. fonts) // Load global data here (assets that must be available in all screens, i.e. fonts)

6
games/light_my_ritual/light_my_ritual.c
View file

@ -53,8 +53,8 @@ void UpdateDrawFrame(void); // Update and Draw one frame
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
int main(void) int main(void)
{ {
// Initialization (Note windowTitle is unused on Android) // Initialization (Note windowTitle is unused on Android)
//--------------------------------------------------------- //---------------------------------------------------------
InitWindow(screenWidth, screenHeight, "LIGHT MY RITUAL! [GGJ16]"); InitWindow(screenWidth, screenHeight, "LIGHT MY RITUAL! [GGJ16]");
// Global data loading (assets that must be available in all screens, i.e. fonts) // Global data loading (assets that must be available in all screens, i.e. fonts)
@ -69,7 +69,7 @@ int main(void)
UnloadImage(image); // Unload image from CPU memory (RAM) UnloadImage(image); // Unload image from CPU memory (RAM)
font = LoadFont("resources/font_arcadian.png"); font = LoadFont("resources/font_arcadian.png");
//doors = LoadTexture("resources/textures/doors.png"); //doors = LoadTexture("resources/textures/doors.png");
//sndDoor = LoadSound("resources/audio/door.ogg"); //sndDoor = LoadSound("resources/audio/door.ogg");
music = LoadMusicStream("resources/audio/ambient.ogg"); music = LoadMusicStream("resources/audio/ambient.ogg");

4
games/skully_escape/player.c
View file

@ -271,11 +271,11 @@ static void DrawLifes(void)
{ {
if (player.numLifes != 0) if (player.numLifes != 0)
{ {
Vector2 position = { 20, GetScreenHeight() - texLife.height - 20 }; Vector2 position = { 20, GetScreenHeight() - texLife.height - 20 };
for(int i = 0; i < player.numLifes; i++) for(int i = 0; i < player.numLifes; i++)
{ {
DrawTexture(texLife, position.x + i*texLife.width, position.y, Fade(RAYWHITE, 0.7f)); DrawTexture(texLife, position.x + i*texLife.width, position.y, Fade(RAYWHITE, 0.7f));
} }
} }
} }

8
games/skully_escape/skully_escape.c
View file

@ -52,8 +52,8 @@ void UpdateDrawFrame(void); // Update and Draw one frame
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
int main(void) int main(void)
{ {
// Initialization (Note windowTitle is unused on Android) // Initialization (Note windowTitle is unused on Android)
//--------------------------------------------------------- //---------------------------------------------------------
InitWindow(screenWidth, screenHeight, "SKULLY ESCAPE [KING GAMEJAM 2015]"); InitWindow(screenWidth, screenHeight, "SKULLY ESCAPE [KING GAMEJAM 2015]");
// Global data loading (assets that must be available in all screens, i.e. fonts) // Global data loading (assets that must be available in all screens, i.e. fonts)
@ -63,7 +63,7 @@ int main(void)
PlayMusicStream(music); PlayMusicStream(music);
font = LoadFont("resources/textures/alagard.png"); font = LoadFont("resources/textures/alagard.png");
doors = LoadTexture("resources/textures/doors.png"); doors = LoadTexture("resources/textures/doors.png");
sndDoor = LoadSound("resources/audio/door.ogg"); sndDoor = LoadSound("resources/audio/door.ogg");
sndScream = LoadSound("resources/audio/scream.ogg"); sndScream = LoadSound("resources/audio/scream.ogg");
@ -90,7 +90,7 @@ int main(void)
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
// Unload all global loaded data (i.e. fonts) here! // Unload all global loaded data (i.e. fonts) here!
UnloadPlayer(); UnloadPlayer();
UnloadFont(font); UnloadFont(font);
UnloadTexture(doors); UnloadTexture(doors);
UnloadSound(sndDoor); UnloadSound(sndDoor);

2
games/transmission/transmission.c
View file

@ -70,7 +70,7 @@ int main(void)
fontMission = LoadFontEx("resources/fonts/traveling_typewriter.ttf", 64, 0, 250); fontMission = LoadFontEx("resources/fonts/traveling_typewriter.ttf", 64, 0, 250);
texButton = LoadTexture("resources/textures/title_ribbon.png"); texButton = LoadTexture("resources/textures/title_ribbon.png");
// UI BUTTON // UI BUTTON
recButton.width = texButton.width; recButton.width = texButton.width;
recButton.height = texButton.height; recButton.height = texButton.height;
recButton.x = screenWidth - recButton.width; recButton.x = screenWidth - recButton.width;

4
games/wave_collector/wave_collector.c
View file

@ -58,8 +58,8 @@ static void UpdateDrawFrame(void); // Update and Draw one frame
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
// Initialization // Initialization
//--------------------------------------------------------- //---------------------------------------------------------
#if defined(PLATFORM_DESKTOP) #if defined(PLATFORM_DESKTOP)
// TODO: Support for dropped files on the exe // TODO: Support for dropped files on the exe

54
projects/4coder/main.c
View file

@ -2,38 +2,38 @@
#include "raylib.h" #include "raylib.h"
int main() { int main() {
int screenWidth = 800; int screenWidth = 800;
int screenHeight = 450; int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib"); InitWindow(screenWidth, screenHeight, "raylib");
Camera cam; Camera cam;
cam.position = (Vector3){ 0.f, 10.f, 8.f }; cam.position = (Vector3){ 0.f, 10.f, 8.f };
cam.target = (Vector3){ 0.f, 0.f, 0.f }; cam.target = (Vector3){ 0.f, 0.f, 0.f };
cam.up = (Vector3){ 0.f, 1.f, 0.f }; cam.up = (Vector3){ 0.f, 1.f, 0.f };
cam.fovy = 60.f; cam.fovy = 60.f;
cam.type = CAMERA_PERSPECTIVE; cam.type = CAMERA_PERSPECTIVE;
Vector3 cubePos = { 0.f, 0.f, 0.f }; Vector3 cubePos = { 0.f, 0.f, 0.f };
SetTargetFPS(60); SetTargetFPS(60);
while (!WindowShouldClose()) { while (!WindowShouldClose()) {
cam.position.x = sin(GetTime()) * 10.f; cam.position.x = sin(GetTime()) * 10.f;
cam.position.z = cos(GetTime()) * 10.f; cam.position.z = cos(GetTime()) * 10.f;
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginMode3D(cam); BeginMode3D(cam);
DrawCube(cubePos, 2.f, 2.f, 2.f, RED); DrawCube(cubePos, 2.f, 2.f, 2.f, RED);
DrawCubeWires(cubePos, 2.f, 2.f, 2.f, MAROON); DrawCubeWires(cubePos, 2.f, 2.f, 2.f, MAROON);
DrawGrid(10, 1.f); DrawGrid(10, 1.f);
EndMode3D(); EndMode3D();
DrawText("This is a raylib example", 10, 40, 20, DARKGRAY); DrawText("This is a raylib example", 10, 40, 20, DARKGRAY);
DrawFPS(10, 10); DrawFPS(10, 10);
EndDrawing(); EndDrawing();
} }
CloseWindow(); CloseWindow();
return 0; return 0;
} }

48
projects/VSCode/main.c
View file

@ -25,21 +25,21 @@ int main()
{ {
// Initialization // Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib"); InitWindow(screenWidth, screenHeight, "raylib");
Camera camera = { 0 }; Camera camera = { 0 };
camera.position = (Vector3){ 10.0f, 10.0f, 8.0f }; camera.position = (Vector3){ 10.0f, 10.0f, 8.0f };
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; camera.target = (Vector3){ 0.0f, 0.0f, 0.0f };
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; camera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
camera.fovy = 60.0f; camera.fovy = 60.0f;
camera.type = CAMERA_PERSPECTIVE; camera.type = CAMERA_PERSPECTIVE;
SetCameraMode(camera, CAMERA_ORBITAL); SetCameraMode(camera, CAMERA_ORBITAL);
Vector3 cubePosition = { 0.0f }; Vector3 cubePosition = { 0.0f };
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -49,30 +49,30 @@ int main()
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
UpdateCamera(&camera); UpdateCamera(&camera);
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginMode3D(camera); BeginMode3D(camera);
DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED); DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, RED);
DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON); DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, MAROON);
DrawGrid(10, 1.0f); DrawGrid(10, 1.0f);
EndMode3D(); EndMode3D();
DrawText("This is a raylib example", 10, 40, 20, DARKGRAY); DrawText("This is a raylib example", 10, 40, 20, DARKGRAY);
DrawFPS(10, 10); DrawFPS(10, 10);
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
} }
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

4
src/easings.h
View file

@ -135,7 +135,7 @@ EASEDEF float EaseQuadOut(float t, float b, float c, float d) { t /= d; return (
EASEDEF float EaseQuadInOut(float t, float b, float c, float d) EASEDEF float EaseQuadInOut(float t, float b, float c, float d)
{ {
if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b); if ((t/=d/2) < 1) return (((c/2)*(t*t)) + b);
return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b); return (-c/2.0f*(((t - 1.0f)*(t - 3.0f)) - 1.0f) + b);
} }
// Exponential Easing functions // Exponential Easing functions
@ -147,7 +147,7 @@ EASEDEF float EaseExpoInOut(float t, float b, float c, float d)
if (t == d) return (b + c); if (t == d) return (b + c);
if ((t/=d/2.0f) < 1.0f) return (c/2.0f*pow(2.0f, 10.0f*(t - 1.0f)) + b); if ((t/=d/2.0f) < 1.0f) return (c/2.0f*pow(2.0f, 10.0f*(t - 1.0f)) + b);
return (c/2.0f*(-pow(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b); return (c/2.0f*(-pow(2.0f, -10.0f*(t - 1.0f)) + 2.0f) + b);
} }
// Back Easing functions // Back Easing functions

2
src/models.c
View file

@ -2482,7 +2482,7 @@ bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, floa
/* /*
float dx = centerA.x - centerB.x; // X distance between centers float dx = centerA.x - centerB.x; // X distance between centers
float dy = centerA.y - centerB.y; // Y distance between centers float dy = centerA.y - centerB.y; // Y distance between centers
float dz = centerA.z - centerB.z; // Y distance between centers float dz = centerA.z - centerB.z; // Z distance between centers
float distance = sqrtf(dx*dx + dy*dy + dz*dz); // Distance between centers float distance = sqrtf(dx*dx + dy*dy + dz*dz); // Distance between centers

2
src/raylib.h
View file

@ -33,7 +33,7 @@
* [core] rgif (Charlie Tangora, Ramon Santamaria) for GIF recording * [core] rgif (Charlie Tangora, Ramon Santamaria) for GIF recording
* [textures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...) * [textures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
* [textures] stb_image_write (Sean Barret) for image writting (BMP, TGA, PNG, JPG) * [textures] stb_image_write (Sean Barret) for image writting (BMP, TGA, PNG, JPG)
* [textures] stb_image_resize (Sean Barret) for image resizing algorythms * [textures] stb_image_resize (Sean Barret) for image resizing algorithms
* [textures] stb_perlin (Sean Barret) for Perlin noise image generation * [textures] stb_perlin (Sean Barret) for Perlin noise image generation
* [text] stb_truetype (Sean Barret) for ttf fonts loading * [text] stb_truetype (Sean Barret) for ttf fonts loading
* [text] stb_rect_pack (Sean Barret) for rectangles packing * [text] stb_rect_pack (Sean Barret) for rectangles packing

72
src/raymath.h
View file

@ -20,7 +20,7 @@
* *
* LICENSE: zlib/libpng * LICENSE: zlib/libpng
* *
* Copyright (c) 2015-2017 Ramon Santamaria (@raysan5) * Copyright (c) 2015-2019 Ramon Santamaria (@raysan5)
* *
* This software is provided "as-is", without any express or implied warranty. In no event * This software is provided "as-is", without any express or implied warranty. In no event
* will the authors be held liable for any damages arising from the use of this software. * will the authors be held liable for any damages arising from the use of this software.
@ -148,7 +148,7 @@ RMDEF float Clamp(float value, float min, float max)
return res > max ? max : res; return res > max ? max : res;
} }
// Calculate linear interpolation between two vectors // Calculate linear interpolation between two floats
RMDEF float Lerp(float start, float end, float amount) RMDEF float Lerp(float start, float end, float amount)
{ {
return start + amount*(end - start); return start + amount*(end - start);
@ -225,8 +225,8 @@ RMDEF Vector2 Vector2Scale(Vector2 v, float scale)
// Multiply vector by vector // Multiply vector by vector
RMDEF Vector2 Vector2MultiplyV(Vector2 v1, Vector2 v2) RMDEF Vector2 Vector2MultiplyV(Vector2 v1, Vector2 v2)
{ {
Vector2 result = { v1.x*v2.x, v1.y*v2.y }; Vector2 result = { v1.x*v2.x, v1.y*v2.y };
return result; return result;
} }
// Negate vector // Negate vector
@ -246,8 +246,8 @@ RMDEF Vector2 Vector2Divide(Vector2 v, float div)
// Divide vector by vector // Divide vector by vector
RMDEF Vector2 Vector2DivideV(Vector2 v1, Vector2 v2) RMDEF Vector2 Vector2DivideV(Vector2 v1, Vector2 v2)
{ {
Vector2 result = { v1.x/v2.x, v1.y/v2.y }; Vector2 result = { v1.x/v2.x, v1.y/v2.y };
return result; return result;
} }
// Normalize provided vector // Normalize provided vector
@ -388,15 +388,15 @@ RMDEF Vector3 Vector3Negate(Vector3 v)
// Divide vector by a float value // Divide vector by a float value
RMDEF Vector3 Vector3Divide(Vector3 v, float div) RMDEF Vector3 Vector3Divide(Vector3 v, float div)
{ {
Vector3 result = { v.x / div, v.y / div, v.z / div }; Vector3 result = { v.x / div, v.y / div, v.z / div };
return result; return result;
} }
// Divide vector by vector // Divide vector by vector
RMDEF Vector3 Vector3DivideV(Vector3 v1, Vector3 v2) RMDEF Vector3 Vector3DivideV(Vector3 v1, Vector3 v2)
{ {
Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z }; Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z };
return result; return result;
} }
// Normalize provided vector // Normalize provided vector
@ -1159,7 +1159,7 @@ RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
// Above lines are equivalent to: // Above lines are equivalent to:
//Quaternion result = QuaternionNlerp(q, QuaternionIdentity(), 0.5f); //Quaternion result = QuaternionNlerp(q, QuaternionIdentity(), 0.5f);
return result; return result;
} }
// Returns a quaternion for a given rotation matrix // Returns a quaternion for a given rotation matrix
@ -1320,21 +1320,21 @@ RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle
// Returns he quaternion equivalent to Euler angles // Returns he quaternion equivalent to Euler angles
RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw) RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw)
{ {
Quaternion q = { 0 }; Quaternion q = { 0 };
float x0 = cosf(roll*0.5f); float x0 = cosf(roll*0.5f);
float x1 = sinf(roll*0.5f); float x1 = sinf(roll*0.5f);
float y0 = cosf(pitch*0.5f); float y0 = cosf(pitch*0.5f);
float y1 = sinf(pitch*0.5f); float y1 = sinf(pitch*0.5f);
float z0 = cosf(yaw*0.5f); float z0 = cosf(yaw*0.5f);
float z1 = sinf(yaw*0.5f); float z1 = sinf(yaw*0.5f);
q.x = x1*y0*z0 - x0*y1*z1; q.x = x1*y0*z0 - x0*y1*z1;
q.y = x0*y1*z0 + x1*y0*z1; q.y = x0*y1*z0 + x1*y0*z1;
q.z = x0*y0*z1 - x1*y1*z0; q.z = x0*y0*z1 - x1*y1*z0;
q.w = x0*y0*z0 + x1*y1*z1; q.w = x0*y0*z0 + x1*y1*z1;
return q; return q;
} }
// Return the Euler angles equivalent to quaternion (roll, pitch, yaw) // Return the Euler angles equivalent to quaternion (roll, pitch, yaw)
@ -1343,21 +1343,21 @@ RMDEF Vector3 QuaternionToEuler(Quaternion q)
{ {
Vector3 result = { 0 }; Vector3 result = { 0 };
// roll (x-axis rotation) // roll (x-axis rotation)
float x0 = 2.0f*(q.w*q.x + q.y*q.z); float x0 = 2.0f*(q.w*q.x + q.y*q.z);
float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y); float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y);
result.x = atan2f(x0, x1)*RAD2DEG; result.x = atan2f(x0, x1)*RAD2DEG;
// pitch (y-axis rotation) // pitch (y-axis rotation)
float y0 = 2.0f*(q.w*q.y - q.z*q.x); float y0 = 2.0f*(q.w*q.y - q.z*q.x);
y0 = y0 > 1.0f ? 1.0f : y0; y0 = y0 > 1.0f ? 1.0f : y0;
y0 = y0 < -1.0f ? -1.0f : y0; y0 = y0 < -1.0f ? -1.0f : y0;
result.y = asinf(y0)*RAD2DEG; result.y = asinf(y0)*RAD2DEG;
// yaw (z-axis rotation) // yaw (z-axis rotation)
float z0 = 2.0f*(q.w*q.z + q.x*q.y); float z0 = 2.0f*(q.w*q.z + q.x*q.y);
float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z); float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z);
result.z = atan2f(z0, z1)*RAD2DEG; result.z = atan2f(z0, z1)*RAD2DEG;
return result; return result;
} }

2
src/rglfw.c
View file

@ -46,7 +46,7 @@
#define _GLFW_USE_RETINA // To have windows use the full resolution of Retina displays #define _GLFW_USE_RETINA // To have windows use the full resolution of Retina displays
#endif #endif
#if defined(__TINYC__) #if defined(__TINYC__)
#define _WIN32_WINNT_WINXP 0x0501 #define _WIN32_WINNT_WINXP 0x0501
#endif #endif
// NOTE: _GLFW_MIR experimental platform not supported at this moment // NOTE: _GLFW_MIR experimental platform not supported at this moment

5
src/textures.c
View file

@ -823,14 +823,15 @@ void ExportImageAsCode(Image image, const char *fileName)
FILE *txtFile = fopen(fileName, "wt"); FILE *txtFile = fopen(fileName, "wt");
fprintf(txtFile, "\n//////////////////////////////////////////////////////////////////////////////////////\n"); fprintf(txtFile, "\n");
fprintf(txtFile, "////////////////////////////////////////////////////////////////////////////////////////\n");
fprintf(txtFile, "// //\n"); fprintf(txtFile, "// //\n");
fprintf(txtFile, "// ImageAsCode exporter v1.0 - Image pixel data exported as an array of bytes //\n"); fprintf(txtFile, "// ImageAsCode exporter v1.0 - Image pixel data exported as an array of bytes //\n");
fprintf(txtFile, "// //\n"); fprintf(txtFile, "// //\n");
fprintf(txtFile, "// more info and bugs-report: github.com/raysan5/raylib //\n"); fprintf(txtFile, "// more info and bugs-report: github.com/raysan5/raylib //\n");
fprintf(txtFile, "// feedback and support: ray[at]raylib.com //\n"); fprintf(txtFile, "// feedback and support: ray[at]raylib.com //\n");
fprintf(txtFile, "// //\n"); fprintf(txtFile, "// //\n");
fprintf(txtFile, "// Copyright (c) 2018 Ramon Santamaria (@raysan5) //\n"); fprintf(txtFile, "// Copyright (c) 2019 Ramon Santamaria (@raysan5) //\n");
fprintf(txtFile, "// //\n"); fprintf(txtFile, "// //\n");
fprintf(txtFile, "////////////////////////////////////////////////////////////////////////////////////////\n\n"); fprintf(txtFile, "////////////////////////////////////////////////////////////////////////////////////////\n\n");