twix/raylib
1
0
Fork 0
mirror of https://github.com/raysan5/raylib.git synced 2026-04-17 20:49:10 -04:00
Code Issues Packages Projects Releases Wiki Activity

REVIEWED: examples memory allocators, using raylib provided macros

Browse Source
This commit is contained in:
Ray
2026-03-23 11:53:57 +01:00
parent 7e8aca00b6
commit ca1baca7c2
5 changed files with 59 additions and 53 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
examples/core/core_random_sequence.c
View File

@ -111,7 +111,7 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
free(rectangles); RL_FREE(rectangles);
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

94
examples/shapes/shapes_ball_physics.c
View File

@ -17,15 +17,19 @@
#include "raylib.h" #include "raylib.h"
#include <stdlib.h> #include <stdlib.h> // Required for: malloc(), free()
#include <math.h> #include <math.h> // Required for: hypot()
#define MAX_BALLS 5000 // Maximum quantity of balls #define MAX_BALLS 5000 // Maximum quantity of balls
//----------------------------------------------------------------------------------
// Types and Structures Definition
//----------------------------------------------------------------------------------
// Ball data type
typedef struct Ball { typedef struct Ball {
Vector2 pos; // Position Vector2 position;
Vector2 vel; // Velocity Vector2 speed;
Vector2 ppos; // Previous position Vector2 prevPosition;
float radius; float radius;
float friction; float friction;
float elasticity; float elasticity;
@ -45,11 +49,13 @@ int main(void)
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - ball physics"); InitWindow(screenWidth, screenHeight, "raylib [shapes] example - ball physics");
Ball *balls = (Ball*)malloc(sizeof(Ball)*MAX_BALLS); Ball *balls = (Ball*)RL_MALLOC(sizeof(Ball)*MAX_BALLS);
// Init first ball in the array
balls[0] = (Ball){ balls[0] = (Ball){
.pos = { GetScreenWidth()/2.0f, GetScreenHeight()/2.0f }, .position = { GetScreenWidth()/2.0f, GetScreenHeight()/2.0f },
.vel = { 200, 200 }, .speed = { 200, 200 },
.ppos = { 0 }, .prevPosition = { 0 },
.radius = 40, .radius = 40,
.friction = 0.99f, .friction = 0.99f,
.elasticity = 0.9f, .elasticity = 0.9f,
@ -58,12 +64,12 @@ int main(void)
}; };
int ballCount = 1; int ballCount = 1;
Ball *grabbedBall = NULL; // A pointer to the current ball that is grabbed Ball *grabbedBall = NULL; // A pointer to the current ball that is grabbed
Vector2 pressOffset = { 0 }; // Mouse press offset relative to the ball that grabbedd Vector2 pressOffset = { 0 }; // Mouse press offset relative to the ball that grabbedd
float gravity = 100; // World gravity float gravity = 100; // World gravity
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//--------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------
// Main game loop // Main game loop
@ -80,8 +86,8 @@ int main(void)
for (int i = ballCount - 1; i >= 0; i--) for (int i = ballCount - 1; i >= 0; i--)
{ {
Ball *ball = &balls[i]; Ball *ball = &balls[i];
pressOffset.x = mousePos.x - ball->pos.x; pressOffset.x = mousePos.x - ball->position.x;
pressOffset.y = mousePos.y - ball->pos.y; pressOffset.y = mousePos.y - ball->position.y;
// If the distance between the ball position and the mouse press position // If the distance between the ball position and the mouse press position
// is less than or equal to the ball radius, the event occurred inside the ball // is less than or equal to the ball radius, the event occurred inside the ball
@ -110,9 +116,9 @@ int main(void)
if (ballCount < MAX_BALLS) if (ballCount < MAX_BALLS)
{ {
balls[ballCount++] = (Ball){ balls[ballCount++] = (Ball){
.pos = mousePos, .position = mousePos,
.vel = { (float)GetRandomValue(-300, 300), (float)GetRandomValue(-300, 300) }, .speed = { (float)GetRandomValue(-300, 300), (float)GetRandomValue(-300, 300) },
.ppos = { 0 }, .prevPosition = { 0 },
.radius = 20.0f + (float)GetRandomValue(0, 30), .radius = 20.0f + (float)GetRandomValue(0, 30),
.friction = 0.99f, .friction = 0.99f,
.elasticity = 0.9f, .elasticity = 0.9f,
@ -127,7 +133,7 @@ int main(void)
{ {
for (int i = 0; i < ballCount; i++) for (int i = 0; i < ballCount; i++)
{ {
if (!balls[i].grabbed) balls[i].vel = (Vector2){ (float)GetRandomValue(-2000, 2000), (float)GetRandomValue(-2000, 2000) }; if (!balls[i].grabbed) balls[i].speed = (Vector2){ (float)GetRandomValue(-2000, 2000), (float)GetRandomValue(-2000, 2000) };
} }
} }
@ -143,49 +149,49 @@ int main(void)
if (!ball->grabbed) if (!ball->grabbed)
{ {
// Ball repositioning using the velocity // Ball repositioning using the velocity
ball->pos.x += ball->vel.x * delta; ball->position.x += ball->speed.x * delta;
ball->pos.y += ball->vel.y * delta; ball->position.y += ball->speed.y * delta;
// Does the ball hit the screen right boundary? // Does the ball hit the screen right boundary?
if ((ball->pos.x + ball->radius) >= screenWidth) if ((ball->position.x + ball->radius) >= screenWidth)
{ {
ball->pos.x = screenWidth - ball->radius; // Ball repositioning ball->position.x = screenWidth - ball->radius; // Ball repositioning
ball->vel.x = -ball->vel.x*ball->elasticity; // Elasticity makes the ball lose 10% of its velocity on hit ball->speed.x = -ball->speed.x*ball->elasticity; // Elasticity makes the ball lose 10% of its velocity on hit
} }
// Does the ball hit the screen left boundary? // Does the ball hit the screen left boundary?
else if ((ball->pos.x - ball->radius) <= 0) else if ((ball->position.x - ball->radius) <= 0)
{ {
ball->pos.x = ball->radius; ball->position.x = ball->radius;
ball->vel.x = -ball->vel.x*ball->elasticity; ball->speed.x = -ball->speed.x*ball->elasticity;
} }
// The same for y axis // The same for y axis
if ((ball->pos.y + ball->radius) >= screenHeight) if ((ball->position.y + ball->radius) >= screenHeight)
{ {
ball->pos.y = screenHeight - ball->radius; ball->position.y = screenHeight - ball->radius;
ball->vel.y = -ball->vel.y*ball->elasticity; ball->speed.y = -ball->speed.y*ball->elasticity;
} }
else if ((ball->pos.y - ball->radius) <= 0) else if ((ball->position.y - ball->radius) <= 0)
{ {
ball->pos.y = ball->radius; ball->position.y = ball->radius;
ball->vel.y = -ball->vel.y*ball->elasticity; ball->speed.y = -ball->speed.y*ball->elasticity;
} }
// Friction makes the ball lose 1% of its velocity each frame // Friction makes the ball lose 1% of its velocity each frame
ball->vel.x = ball->vel.x*ball->friction; ball->speed.x = ball->speed.x*ball->friction;
// Gravity affects only the y axis // Gravity affects only the y axis
ball->vel.y = ball->vel.y*ball->friction + gravity; ball->speed.y = ball->speed.y*ball->friction + gravity;
} }
else else
{ {
// Ball repositioning using the mouse position // Ball repositioning using the mouse position
ball->pos.x = mousePos.x - pressOffset.x; ball->position.x = mousePos.x - pressOffset.x;
ball->pos.y = mousePos.y - pressOffset.y; ball->position.y = mousePos.y - pressOffset.y;
// While the ball is grabbed, recalculates its velocity // While the ball is grabbed, recalculates its velocity
ball->vel.x = (ball->pos.x - ball->ppos.x)/delta; ball->speed.x = (ball->position.x - ball->prevPosition.x)/delta;
ball->vel.y = (ball->pos.y - ball->ppos.y)/delta; ball->speed.y = (ball->position.y - ball->prevPosition.y)/delta;
ball->ppos = ball->pos; ball->prevPosition = ball->position;
} }
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -198,8 +204,8 @@ int main(void)
for (int i = 0; i < ballCount; i++) for (int i = 0; i < ballCount; i++)
{ {
DrawCircleV(balls[i].pos, balls[i].radius, balls[i].color); DrawCircleV(balls[i].position, balls[i].radius, balls[i].color);
DrawCircleLinesV(balls[i].pos, balls[i].radius, BLACK); DrawCircleLinesV(balls[i].position, balls[i].radius, BLACK);
} }
DrawText("grab a ball by pressing with the mouse and throw it by releasing", 10, 10, 10, DARKGRAY); DrawText("grab a ball by pressing with the mouse and throw it by releasing", 10, 10, 10, DARKGRAY);
@ -215,7 +221,7 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
free(balls); RL_FREE(balls);
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------

4
examples/text/text_codepoints_loading.c
View File

@ -61,7 +61,7 @@ int main(void)
SetTextLineSpacing(20); // Set line spacing for multiline text (when line breaks are included '\n') SetTextLineSpacing(20); // Set line spacing for multiline text (when line breaks are included '\n')
// Free codepoints, atlas has already been generated // Free codepoints, atlas has already been generated
free(codepointsNoDups); RL_FREE(codepointsNoDups);
bool showFontAtlas = false; bool showFontAtlas = false;
@ -139,7 +139,7 @@ int main(void)
static int *CodepointRemoveDuplicates(int *codepoints, int codepointCount, int *codepointsResultCount) static int *CodepointRemoveDuplicates(int *codepoints, int codepointCount, int *codepointsResultCount)
{ {
int codepointsNoDupsCount = codepointCount; int codepointsNoDupsCount = codepointCount;
int *codepointsNoDups = (int *)calloc(codepointCount, sizeof(int)); int *codepointsNoDups = (int *)RL_CALLOC(codepointCount, sizeof(int));
memcpy(codepointsNoDups, codepoints, codepointCount*sizeof(int)); memcpy(codepointsNoDups, codepoints, codepointCount*sizeof(int));
// Remove duplicates // Remove duplicates

4
examples/textures/textures_bunnymark.c
View File

@ -47,7 +47,7 @@ int main(void)
// Load bunny texture // Load bunny texture
Texture2D texBunny = LoadTexture("resources/raybunny.png"); Texture2D texBunny = LoadTexture("resources/raybunny.png");
Bunny *bunnies = (Bunny *)malloc(MAX_BUNNIES*sizeof(Bunny)); // Bunnies array Bunny *bunnies = (Bunny *)RL_MALLOC(MAX_BUNNIES*sizeof(Bunny)); // Bunnies array
int bunniesCount = 0; // Bunnies counter int bunniesCount = 0; // Bunnies counter
@ -126,7 +126,7 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
free(bunnies); // Unload bunnies data array RL_FREE(bunnies); // Unload bunnies data array
UnloadTexture(texBunny); // Unload bunny texture UnloadTexture(texBunny); // Unload bunny texture

8
examples/textures/textures_fog_of_war.c
View File

@ -51,8 +51,8 @@ int main(void)
// NOTE: We can have up to 256 values for tile ids and for tile fog state, // NOTE: We can have up to 256 values for tile ids and for tile fog state,
// probably we don't need that many values for fog state, it can be optimized // probably we don't need that many values for fog state, it can be optimized
// to use only 2 bits per fog state (reducing size by 4) but logic will be a bit more complex // to use only 2 bits per fog state (reducing size by 4) but logic will be a bit more complex
map.tileIds = (unsigned char *)calloc(map.tilesX*map.tilesY, sizeof(unsigned char)); map.tileIds = (unsigned char *)RL_CALLOC(map.tilesX*map.tilesY, sizeof(unsigned char));
map.tileFog = (unsigned char *)calloc(map.tilesX*map.tilesY, sizeof(unsigned char)); map.tileFog = (unsigned char *)RL_CALLOC(map.tilesX*map.tilesY, sizeof(unsigned char));
// Load map tiles (generating 2 random tile ids for testing) // Load map tiles (generating 2 random tile ids for testing)
// NOTE: Map tile ids should be probably loaded from an external map file // NOTE: Map tile ids should be probably loaded from an external map file
@ -149,8 +149,8 @@ int main(void)
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
free(map.tileIds); // Free allocated map tile ids RL_FREE(map.tileIds); // Free allocated map tile ids
free(map.tileFog); // Free allocated map tile fog state RL_FREE(map.tileFog); // Free allocated map tile fog state
UnloadRenderTexture(fogOfWar); // Unload render texture UnloadRenderTexture(fogOfWar); // Unload render texture