MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace tabs with spaces

Browse Source
This commit is contained in:
Leandro Gabriel 2019-08-02 22:07:26 -03:00
parent 50786b655b
commit 3c19d8cd16
19 changed files with 744 additions and 744 deletions
Show Stats 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;
} }

56
examples/network/network_resolve_host.c
View File

@ -28,30 +28,30 @@ 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,
0 // Uncomment any of these flags 0 // Uncomment any of these flags
// ADDRESS_INFO_NUMERICHOST // or try them in conjunction to // ADDRESS_INFO_NUMERICHOST // or try them in conjunction to
// ADDRESS_INFO_NUMERICSERV // specify custom behaviour from // ADDRESS_INFO_NUMERICSERV // specify custom behaviour from
// ADDRESS_INFO_DNS_ONLY // the function getaddrinfo() // ADDRESS_INFO_DNS_ONLY // the function getaddrinfo()
// ADDRESS_INFO_ALL // // ADDRESS_INFO_ALL //
// ADDRESS_INFO_FQDN // e.g. ADDRESS_INFO_CANONNAME | ADDRESS_INFO_NUMERICSERV // ADDRESS_INFO_FQDN // e.g. ADDRESS_INFO_CANONNAME | ADDRESS_INFO_NUMERICSERV
, ,
addr addr
); );
@ -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

60
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)

8
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");
@ -270,7 +270,7 @@ void UpdateDrawFrame(void)
case GAMEPLAY: DrawGameplayScreen(); break; case GAMEPLAY: DrawGameplayScreen(); break;
default: break; default: break;
} }
if (onTransition) DrawTransition(); if (onTransition) DrawTransition();
//DrawFPS(10, 10); //DrawFPS(10, 10);

6
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));
} }
} }
} }

12
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,10 +63,10 @@ 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");
InitPlayer(); InitPlayer();
// Setup and Init first screen // Setup and Init first screen
@ -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);
@ -397,7 +397,7 @@ void UpdateDrawFrame(void)
case ENDING: DrawEndingScreen(); break; case ENDING: DrawEndingScreen(); break;
default: break; default: break;
} }
if (onTransition) DrawTransition(); if (onTransition) DrawTransition();
//DrawFPS(10, 10); //DrawFPS(10, 10);

6
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;
@ -121,7 +121,7 @@ int main(void)
UnloadFont(fontMission); UnloadFont(fontMission);
UnloadTexture(texButton); UnloadTexture(texButton);
CloseAudioDevice(); // Close audio context CloseAudioDevice(); // Close audio context
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
@ -438,7 +438,7 @@ bool IsButtonPressed()
} }
} }
else fadeButton = 0.80f; else fadeButton = 0.80f;
return false; return false;
} }

6
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
@ -299,7 +299,7 @@ static void UpdateDrawFrame(void)
case ENDING: DrawEndingScreen(); break; case ENDING: DrawEndingScreen(); break;
default: break; default: break;
} }
// Draw full screen rectangle in front of everything // Draw full screen rectangle in front of everything
if (onTransition) DrawTransition(); if (onTransition) DrawTransition();

56
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;
} }

50
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
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------