mirror/raylib
1
0
Fork 0
mirror of https://github.com/raysan5/raylib.git synced 2025-12-06 06:13:10 +00:00
Code Issues Packages Projects Releases Wiki Activity

REVIEWED: examples: Replace TABS and Remove trailing spaces

Browse Source
This commit is contained in:
Ray 2025-11-19 13:18:10 +01:00
parent bd21d74914
commit 0b9f463e64
36 changed files with 440 additions and 447 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/audio/audio_fft_spectrum_visualizer.c
View File

@ -86,7 +86,7 @@ int main(void)
Vector2 iResolution = { (float)screenWidth, (float)screenHeight }; Vector2 iResolution = { (float)screenWidth, (float)screenHeight };
Shader shader = LoadShader(0, TextFormat("resources/shaders/glsl%i/fft.fs", GLSL_VERSION)); Shader shader = LoadShader(0, TextFormat("resources/shaders/glsl%i/fft.fs", GLSL_VERSION));
int iResolutionLocation = GetShaderLocation(shader, "iResolution"); int iResolutionLocation = GetShaderLocation(shader, "iResolution");
int iChannel0Location = GetShaderLocation(shader, "iChannel0"); int iChannel0Location = GetShaderLocation(shader, "iChannel0");
SetShaderValue(shader, iResolutionLocation, &iResolution, SHADER_UNIFORM_VEC2); SetShaderValue(shader, iResolutionLocation, &iResolution, SHADER_UNIFORM_VEC2);
@ -153,16 +153,16 @@ int main(void)
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginShaderMode(shader); BeginShaderMode(shader);
SetShaderValueTexture(shader, iChannel0Location, fftTexture); SetShaderValueTexture(shader, iChannel0Location, fftTexture);
DrawTextureRec(bufferA.texture, DrawTextureRec(bufferA.texture,
(Rectangle){ 0, 0, (float)screenWidth, (float)-screenHeight }, (Rectangle){ 0, 0, (float)screenWidth, (float)-screenHeight },
(Vector2){ 0, 0 }, WHITE); (Vector2){ 0, 0 }, WHITE);
EndShaderMode(); EndShaderMode();
EndDrawing(); EndDrawing();
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
} }

2
examples/core/core_compute_hash.c
View File

@ -64,7 +64,7 @@ int main(void)
// Encode data to Base64 string (includes NULL terminator), memory must be MemFree() // Encode data to Base64 string (includes NULL terminator), memory must be MemFree()
base64Text = EncodeDataBase64((unsigned char *)textInput, textInputLen, &base64TextSize); base64Text = EncodeDataBase64((unsigned char *)textInput, textInputLen, &base64TextSize);
hashCRC32 = ComputeCRC32((unsigned char *)textInput, textInputLen); // Compute CRC32 hash code (4 bytes) hashCRC32 = ComputeCRC32((unsigned char *)textInput, textInputLen); // Compute CRC32 hash code (4 bytes)
hashMD5 = ComputeMD5((unsigned char *)textInput, textInputLen); // Compute MD5 hash code, returns static int[4] (16 bytes) hashMD5 = ComputeMD5((unsigned char *)textInput, textInputLen); // Compute MD5 hash code, returns static int[4] (16 bytes)
hashSHA1 = ComputeSHA1((unsigned char *)textInput, textInputLen); // Compute SHA1 hash code, returns static int[5] (20 bytes) hashSHA1 = ComputeSHA1((unsigned char *)textInput, textInputLen); // Compute SHA1 hash code, returns static int[5] (20 bytes)

4
examples/core/core_delta_time.c
View File

@ -59,7 +59,7 @@ int main(void)
// GetFrameTime() returns the time it took to draw the last frame, in seconds (usually called delta time) // GetFrameTime() returns the time it took to draw the last frame, in seconds (usually called delta time)
// Uses the delta time to make the circle look like it's moving at a "consistent" speed regardless of FPS // Uses the delta time to make the circle look like it's moving at a "consistent" speed regardless of FPS
// Multiply by 6.0 (an arbitrary value) in order to make the speed // Multiply by 6.0 (an arbitrary value) in order to make the speed
// visually closer to the other circle (at 60 fps), for comparison // visually closer to the other circle (at 60 fps), for comparison
deltaCircle.x += GetFrameTime()*6.0f*speed; deltaCircle.x += GetFrameTime()*6.0f*speed;
// This circle can move faster or slower visually depending on the FPS // This circle can move faster or slower visually depending on the FPS
@ -68,7 +68,7 @@ int main(void)
// If either circle is off the screen, reset it back to the start // If either circle is off the screen, reset it back to the start
if (deltaCircle.x > screenWidth) deltaCircle.x = 0; if (deltaCircle.x > screenWidth) deltaCircle.x = 0;
if (frameCircle.x > screenWidth) frameCircle.x = 0; if (frameCircle.x > screenWidth) frameCircle.x = 0;
// Reset both circles positions // Reset both circles positions
if (IsKeyPressed(KEY_R)) if (IsKeyPressed(KEY_R))
{ {

32
examples/core/core_input_actions.c
View File

@ -17,7 +17,7 @@
// Simple example for decoding input as actions, allowing remapping of input to different keys or gamepad buttons // Simple example for decoding input as actions, allowing remapping of input to different keys or gamepad buttons
// For example instead of using `IsKeyDown(KEY_LEFT)`, you can use `IsActionDown(ACTION_LEFT)` // For example instead of using `IsKeyDown(KEY_LEFT)`, you can use `IsActionDown(ACTION_LEFT)`
// which can be reassigned to e.g. KEY_A and also assigned to a gamepad button. the action will trigger with either gamepad or keys // which can be reassigned to e.g. KEY_A and also assigned to a gamepad button. the action will trigger with either gamepad or keys
#include "raylib.h" #include "raylib.h"
@ -44,7 +44,7 @@ typedef struct ActionInput {
// Global Variables Definition // Global Variables Definition
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
static int gamepadIndex = 0; // Gamepad default index static int gamepadIndex = 0; // Gamepad default index
static ActionInput actionInputs[MAX_ACTION] = { 0 }; static ActionInput actionInputs[MAX_ACTION] = { 0 };
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Module Functions Declaration // Module Functions Declaration
@ -67,15 +67,15 @@ int main(void)
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [core] example - input actions"); InitWindow(screenWidth, screenHeight, "raylib [core] example - input actions");
// Set default actions // Set default actions
char actionSet = 0; char actionSet = 0;
SetActionsDefault(); SetActionsDefault();
bool releaseAction = false; bool releaseAction = false;
Vector2 position = (Vector2){ 400.0f, 200.0f }; Vector2 position = (Vector2){ 400.0f, 200.0f };
Vector2 size = (Vector2){ 40.0f, 40.0f }; Vector2 size = (Vector2){ 40.0f, 40.0f };
SetTargetFPS(60); SetTargetFPS(60);
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -85,7 +85,7 @@ int main(void)
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
gamepadIndex = 0; // Set gamepad being checked gamepadIndex = 0; // Set gamepad being checked
if (IsActionDown(ACTION_UP)) position.y -= 2; if (IsActionDown(ACTION_UP)) position.y -= 2;
if (IsActionDown(ACTION_DOWN)) position.y += 2; if (IsActionDown(ACTION_DOWN)) position.y += 2;
if (IsActionDown(ACTION_LEFT)) position.x -= 2; if (IsActionDown(ACTION_LEFT)) position.x -= 2;
@ -95,12 +95,12 @@ int main(void)
position.x = (screenWidth-size.x)/2; position.x = (screenWidth-size.x)/2;
position.y = (screenHeight-size.y)/2; position.y = (screenHeight-size.y)/2;
} }
// Register release action for one frame // Register release action for one frame
releaseAction = false; releaseAction = false;
if (IsActionReleased(ACTION_FIRE)) releaseAction = true; if (IsActionReleased(ACTION_FIRE)) releaseAction = true;
// Switch control scheme by pressing TAB // Switch control scheme by pressing TAB
if (IsKeyPressed(KEY_TAB)) if (IsKeyPressed(KEY_TAB))
{ {
actionSet = !actionSet; actionSet = !actionSet;
@ -116,7 +116,7 @@ int main(void)
ClearBackground(GRAY); ClearBackground(GRAY);
DrawRectangleV(position, size, releaseAction? BLUE : RED); DrawRectangleV(position, size, releaseAction? BLUE : RED);
DrawText((actionSet == 0)? "Current input set: WASD (default)" : "Current input set: Cursor", 10, 10, 20, WHITE); DrawText((actionSet == 0)? "Current input set: WASD (default)" : "Current input set: Cursor", 10, 10, 20, WHITE);
DrawText("Use TAB key to toggles Actions keyset", 10, 50, 20, GREEN); DrawText("Use TAB key to toggles Actions keyset", 10, 50, 20, GREEN);
@ -140,9 +140,9 @@ int main(void)
static bool IsActionPressed(int action) static bool IsActionPressed(int action)
{ {
bool result = false; bool result = false;
if (action < MAX_ACTION) result = (IsKeyPressed(actionInputs[action].key) || IsGamepadButtonPressed(gamepadIndex, actionInputs[action].button)); if (action < MAX_ACTION) result = (IsKeyPressed(actionInputs[action].key) || IsGamepadButtonPressed(gamepadIndex, actionInputs[action].button));
return result; return result;
} }
@ -151,20 +151,20 @@ static bool IsActionPressed(int action)
static bool IsActionReleased(int action) static bool IsActionReleased(int action)
{ {
bool result = false; bool result = false;
if (action < MAX_ACTION) result = (IsKeyReleased(actionInputs[action].key) || IsGamepadButtonReleased(gamepadIndex, actionInputs[action].button)); if (action < MAX_ACTION) result = (IsKeyReleased(actionInputs[action].key) || IsGamepadButtonReleased(gamepadIndex, actionInputs[action].button));
return result; return result;
} }
// Check action key/button down // Check action key/button down
// NOTE: Combines key down and gamepad button down in one action // NOTE: Combines key down and gamepad button down in one action
static bool IsActionDown(int action) static bool IsActionDown(int action)
{ {
bool result = false; bool result = false;
if (action < MAX_ACTION) result = (IsKeyDown(actionInputs[action].key) || IsGamepadButtonDown(gamepadIndex, actionInputs[action].button)); if (action < MAX_ACTION) result = (IsKeyDown(actionInputs[action].key) || IsGamepadButtonDown(gamepadIndex, actionInputs[action].button));
return result; return result;
} }

4
examples/core/core_input_gamepad.c
View File

@ -50,7 +50,7 @@ int main(void)
const float rightStickDeadzoneY = 0.1f; const float rightStickDeadzoneY = 0.1f;
const float leftTriggerDeadzone = -0.9f; const float leftTriggerDeadzone = -0.9f;
const float rightTriggerDeadzone = -0.9f; const float rightTriggerDeadzone = -0.9f;
Rectangle vibrateButton = { 0 }; Rectangle vibrateButton = { 0 };
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
@ -97,7 +97,7 @@ int main(void)
if (leftTrigger < leftTriggerDeadzone) leftTrigger = -1.0f; if (leftTrigger < leftTriggerDeadzone) leftTrigger = -1.0f;
if (rightTrigger < rightTriggerDeadzone) rightTrigger = -1.0f; if (rightTrigger < rightTriggerDeadzone) rightTrigger = -1.0f;
if ((TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_1) > -1) || if ((TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_1) > -1) ||
(TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_2) > -1)) (TextFindIndex(TextToLower(GetGamepadName(gamepad)), XBOX_ALIAS_2) > -1))
{ {
DrawTexture(texXboxPad, 0, 0, DARKGRAY); DrawTexture(texXboxPad, 0, 0, DARKGRAY);

2
examples/core/core_input_gestures.c
View File

@ -118,6 +118,6 @@ int main(void)
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;
} }

6
examples/core/core_input_virtual_controls.c
View File

@ -6,7 +6,7 @@
* *
* Example originally created with raylib 5.0, last time updated with raylib 5.0 * Example originally created with raylib 5.0, last time updated with raylib 5.0
* *
* Example contributed by GreenSnakeLinux (@GreenSnakeLinux), * Example contributed by GreenSnakeLinux (@GreenSnakeLinux),
* reviewed by Ramon Santamaria (@raysan5), oblerion (@oblerion) and danilwhale (@danilwhale) * reviewed by Ramon Santamaria (@raysan5), oblerion (@oblerion) and danilwhale (@danilwhale)
* *
* Example licensed under an unmodified zlib/libpng license, which is an OSI-certified, * Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
@ -86,7 +86,7 @@ int main(void)
pressedButton = BUTTON_NONE; pressedButton = BUTTON_NONE;
// Make sure user is pressing left mouse button if they're from desktop // Make sure user is pressing left mouse button if they're from desktop
if ((GetTouchPointCount() > 0) || if ((GetTouchPointCount() > 0) ||
((GetTouchPointCount() == 0) && IsMouseButtonDown(MOUSE_BUTTON_LEFT))) ((GetTouchPointCount() == 0) && IsMouseButtonDown(MOUSE_BUTTON_LEFT)))
{ {
// Find nearest D-Pad button to the input position // Find nearest D-Pad button to the input position
@ -113,7 +113,7 @@ int main(void)
default: break; default: break;
}; };
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
// Draw // Draw
//-------------------------------------------------------------------------- //--------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();

20
examples/core/core_monitor_detector.c
View File

@ -66,25 +66,25 @@ int main(void)
for (int i = 0; i < monitorCount; i++) for (int i = 0; i < monitorCount; i++)
{ {
monitors[i] = (MonitorInfo){ monitors[i] = (MonitorInfo){
GetMonitorPosition(i), GetMonitorPosition(i),
GetMonitorName(i), GetMonitorName(i),
GetMonitorWidth(i), GetMonitorWidth(i),
GetMonitorHeight(i), GetMonitorHeight(i),
GetMonitorPhysicalWidth(i), GetMonitorPhysicalWidth(i),
GetMonitorPhysicalHeight(i), GetMonitorPhysicalHeight(i),
GetMonitorRefreshRate(i) GetMonitorRefreshRate(i)
}; };
if (monitors[i].position.x < monitorOffsetX) monitorOffsetX = -(int)monitors[i].position.x; if (monitors[i].position.x < monitorOffsetX) monitorOffsetX = -(int)monitors[i].position.x;
const int width = (int)monitors[i].position.x + monitors[i].width; const int width = (int)monitors[i].position.x + monitors[i].width;
const int height = (int)monitors[i].position.y + monitors[i].height; const int height = (int)monitors[i].position.y + monitors[i].height;
if (maxWidth < width) maxWidth = width; if (maxWidth < width) maxWidth = width;
if (maxHeight < height) maxHeight = height; if (maxHeight < height) maxHeight = height;
} }
if (IsKeyPressed(KEY_ENTER) && (monitorCount > 1)) if (IsKeyPressed(KEY_ENTER) && (monitorCount > 1))
{ {
currentMonitorIndex += 1; currentMonitorIndex += 1;
@ -95,8 +95,8 @@ int main(void)
} }
else currentMonitorIndex = GetCurrentMonitor(); // Get currentMonitorIndex if manually moved else currentMonitorIndex = GetCurrentMonitor(); // Get currentMonitorIndex if manually moved
float monitorScale = 0.6f; float monitorScale = 0.6f;
if (maxHeight > (maxWidth + monitorOffsetX)) monitorScale *= ((float)screenHeight/(float)maxHeight); if (maxHeight > (maxWidth + monitorOffsetX)) monitorScale *= ((float)screenHeight/(float)maxHeight);
else monitorScale *= ((float)screenWidth/(float)(maxWidth + monitorOffsetX)); else monitorScale *= ((float)screenWidth/(float)(maxWidth + monitorOffsetX));
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -125,9 +125,9 @@ int main(void)
// Draw monitor name and information inside the rectangle // Draw monitor name and information inside the rectangle
DrawText(TextFormat("[%i] %s", i, monitors[i].name), (int)rec.x + 10, (int)rec.y + (int)(100*monitorScale), (int)(120*monitorScale), BLUE); DrawText(TextFormat("[%i] %s", i, monitors[i].name), (int)rec.x + 10, (int)rec.y + (int)(100*monitorScale), (int)(120*monitorScale), BLUE);
DrawText( DrawText(
TextFormat("Resolution: [%ipx x %ipx]\nRefreshRate: [%ihz]\nPhysical Size: [%imm x %imm]\nPosition: %3.0f x %3.0f", TextFormat("Resolution: [%ipx x %ipx]\nRefreshRate: [%ihz]\nPhysical Size: [%imm x %imm]\nPosition: %3.0f x %3.0f",
monitors[i].width, monitors[i].width,
monitors[i].height, monitors[i].height,
monitors[i].refreshRate, monitors[i].refreshRate,
monitors[i].physicalWidth, monitors[i].physicalWidth,
monitors[i].physicalHeight, monitors[i].physicalHeight,

4
examples/core/core_undo_redo.c
View File

@ -22,7 +22,7 @@
#define MAX_UNDO_STATES 26 // Maximum undo states supported for the ring buffer #define MAX_UNDO_STATES 26 // Maximum undo states supported for the ring buffer
#define GRID_CELL_SIZE 24 #define GRID_CELL_SIZE 24
#define MAX_GRID_CELLS_X 30 #define MAX_GRID_CELLS_X 30
#define MAX_GRID_CELLS_Y 13 #define MAX_GRID_CELLS_Y 13
@ -57,7 +57,7 @@ int main(void)
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
// We have multiple options to implement an Undo/Redo system // We have multiple options to implement an Undo/Redo system
// Probably the most professional one is using the Command pattern to // Probably the most professional one is using the Command pattern to
// define Actions and store those actions into an array as the events happen, // define Actions and store those actions into an array as the events happen,

4
examples/core/core_viewport_scaling.c
View File

@ -20,7 +20,7 @@
// For itteration purposes and teaching example // For itteration purposes and teaching example
#define RESOLUTION_COUNT 4 #define RESOLUTION_COUNT 4
enum ViewportType enum ViewportType
{ {
// Only upscale, useful for pixel art // Only upscale, useful for pixel art
KEEP_ASPECT_INTEGER, KEEP_ASPECT_INTEGER,
@ -113,7 +113,7 @@ int main(void)
} }
Vector2 mousePosition = GetMousePosition(); Vector2 mousePosition = GetMousePosition();
bool mousePressed = IsMouseButtonPressed(MOUSE_BUTTON_LEFT); bool mousePressed = IsMouseButtonPressed(MOUSE_BUTTON_LEFT);
// Check buttons and rescale // Check buttons and rescale
if (CheckCollisionPointRec(mousePosition, decreaseResolutionButton) && mousePressed){ if (CheckCollisionPointRec(mousePosition, decreaseResolutionButton) && mousePressed){
resolutionIndex = (resolutionIndex + RESOLUTION_COUNT - 1) % RESOLUTION_COUNT; resolutionIndex = (resolutionIndex + RESOLUTION_COUNT - 1) % RESOLUTION_COUNT;

2
examples/models/models_directional_billboard.c
View File

@ -62,7 +62,7 @@ int main(void)
anim_timer += GetFrameTime(); anim_timer += GetFrameTime();
// Update frame index after a certain amount of time (half a second) // Update frame index after a certain amount of time (half a second)
if (anim_timer > 0.5f) if (anim_timer > 0.5f)
{ {
anim_timer = 0.0f; anim_timer = 0.0f;
anim += 1; anim += 1;

208
examples/models/models_loading_vox.c
View File

@ -35,122 +35,122 @@
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
int main(void) int main(void)
{ {
// Initialization // Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
const char *voxFileNames[] = { const char *voxFileNames[] = {
"resources/models/vox/chr_knight.vox", "resources/models/vox/chr_knight.vox",
"resources/models/vox/chr_sword.vox", "resources/models/vox/chr_sword.vox",
"resources/models/vox/monu9.vox", "resources/models/vox/monu9.vox",
"resources/models/vox/fez.vox" "resources/models/vox/fez.vox"
}; };
InitWindow(screenWidth, screenHeight, "raylib [models] example - loading vox"); InitWindow(screenWidth, screenHeight, "raylib [models] example - loading vox");
// Define the camera to look into our 3d world // Define the camera to look into our 3d world
Camera camera = { 0 }; Camera camera = { 0 };
camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position camera.position = (Vector3){ 10.0f, 10.0f, 10.0f }; // Camera position
camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point camera.target = (Vector3){ 0.0f, 0.0f, 0.0f }; // Camera looking at point
camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target) camera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; // Camera up vector (rotation towards target)
camera.fovy = 45.0f; // Camera field-of-view Y camera.fovy = 45.0f; // Camera field-of-view Y
camera.projection = CAMERA_PERSPECTIVE; // Camera projection type camera.projection = CAMERA_PERSPECTIVE; // Camera projection type
// Load MagicaVoxel files // Load MagicaVoxel files
Model models[MAX_VOX_FILES] = { 0 }; Model models[MAX_VOX_FILES] = { 0 };
for (int i = 0; i < MAX_VOX_FILES; i++) for (int i = 0; i < MAX_VOX_FILES; i++)
{ {
// Load VOX file and measure time // Load VOX file and measure time
double t0 = GetTime()*1000.0; double t0 = GetTime()*1000.0;
models[i] = LoadModel(voxFileNames[i]); models[i] = LoadModel(voxFileNames[i]);
double t1 = GetTime()*1000.0; double t1 = GetTime()*1000.0;
TraceLog(LOG_INFO, TextFormat("[%s] Model file loaded in %.3f ms", voxFileNames[i], t1 - t0)); TraceLog(LOG_INFO, TextFormat("[%s] Model file loaded in %.3f ms", voxFileNames[i], t1 - t0));
// Compute model translation matrix to center model on draw position (0, 0 , 0) // Compute model translation matrix to center model on draw position (0, 0 , 0)
BoundingBox bb = GetModelBoundingBox(models[i]); BoundingBox bb = GetModelBoundingBox(models[i]);
Vector3 center = { 0 }; Vector3 center = { 0 };
center.x = bb.min.x + (((bb.max.x - bb.min.x)/2)); center.x = bb.min.x + (((bb.max.x - bb.min.x)/2));
center.z = bb.min.z + (((bb.max.z - bb.min.z)/2)); center.z = bb.min.z + (((bb.max.z - bb.min.z)/2));
Matrix matTranslate = MatrixTranslate(-center.x, 0, -center.z); Matrix matTranslate = MatrixTranslate(-center.x, 0, -center.z);
models[i].transform = matTranslate; models[i].transform = matTranslate;
} }
int currentModel = 0; int currentModel = 0;
Vector3 modelpos = { 0 }; Vector3 modelpos = { 0 };
Vector3 camerarot = { 0 }; Vector3 camerarot = { 0 };
// Load voxel shader // Load voxel shader
Shader shader = LoadShader(TextFormat("resources/shaders/glsl%i/voxel_lighting.vs", GLSL_VERSION), Shader shader = LoadShader(TextFormat("resources/shaders/glsl%i/voxel_lighting.vs", GLSL_VERSION),
TextFormat("resources/shaders/glsl%i/voxel_lighting.fs", GLSL_VERSION)); TextFormat("resources/shaders/glsl%i/voxel_lighting.fs", GLSL_VERSION));
// Get some required shader locations // Get some required shader locations
shader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shader, "viewPos"); shader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shader, "viewPos");
// NOTE: "matModel" location name is automatically assigned on shader loading, // NOTE: "matModel" location name is automatically assigned on shader loading,
// no need to get the location again if using that uniform name // no need to get the location again if using that uniform name
//shader.locs[SHADER_LOC_MATRIX_MODEL] = GetShaderLocation(shader, "matModel"); //shader.locs[SHADER_LOC_MATRIX_MODEL] = GetShaderLocation(shader, "matModel");
// Ambient light level (some basic lighting) // Ambient light level (some basic lighting)
int ambientLoc = GetShaderLocation(shader, "ambient"); int ambientLoc = GetShaderLocation(shader, "ambient");
SetShaderValue(shader, ambientLoc, (float[4]) { 0.1f, 0.1f, 0.1f, 1.0f }, SHADER_UNIFORM_VEC4); SetShaderValue(shader, ambientLoc, (float[4]) { 0.1f, 0.1f, 0.1f, 1.0f }, SHADER_UNIFORM_VEC4);
// Assign out lighting shader to model // Assign out lighting shader to model
for (int i = 0; i < MAX_VOX_FILES; i++) for (int i = 0; i < MAX_VOX_FILES; i++)
{ {
for (int j = 0; j < models[i].materialCount; j++) models[i].materials[j].shader = shader; for (int j = 0; j < models[i].materialCount; j++) models[i].materials[j].shader = shader;
} }
// Create lights // Create lights
Light lights[MAX_LIGHTS] = { 0 }; Light lights[MAX_LIGHTS] = { 0 };
lights[0] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, -20 }, Vector3Zero(), GRAY, shader); lights[0] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, -20 }, Vector3Zero(), GRAY, shader);
lights[1] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, 20 }, Vector3Zero(), GRAY, shader); lights[1] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, 20 }, Vector3Zero(), GRAY, shader);
lights[2] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, 20 }, Vector3Zero(), GRAY, shader); lights[2] = CreateLight(LIGHT_POINT, (Vector3) { -20, 20, 20 }, Vector3Zero(), GRAY, shader);
lights[3] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, -20 }, Vector3Zero(), GRAY, shader); lights[3] = CreateLight(LIGHT_POINT, (Vector3) { 20, -20, -20 }, Vector3Zero(), GRAY, shader);
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
while (!WindowShouldClose()) // Detect window close button or ESC key while (!WindowShouldClose()) // Detect window close button or ESC key
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
if (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE)) if (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE))
{ {
const Vector2 mouseDelta = GetMouseDelta(); const Vector2 mouseDelta = GetMouseDelta();
camerarot.x = mouseDelta.x*0.05f; camerarot.x = mouseDelta.x*0.05f;
camerarot.y = mouseDelta.y*0.05f; camerarot.y = mouseDelta.y*0.05f;
} }
else else
{ {
camerarot.x = 0; camerarot.x = 0;
camerarot.y = 0; camerarot.y = 0;
} }
UpdateCameraPro(&camera, UpdateCameraPro(&camera,
(Vector3){ (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))*0.1f - (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))*0.1f, // Move forward-backward (Vector3){ (IsKeyDown(KEY_W) || IsKeyDown(KEY_UP))*0.1f - (IsKeyDown(KEY_S) || IsKeyDown(KEY_DOWN))*0.1f, // Move forward-backward
(IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT))*0.1f - (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT))*0.1f, // Move right-left (IsKeyDown(KEY_D) || IsKeyDown(KEY_RIGHT))*0.1f - (IsKeyDown(KEY_A) || IsKeyDown(KEY_LEFT))*0.1f, // Move right-left
0.0f }, // Move up-down 0.0f }, // Move up-down
camerarot, // Camera rotation camerarot, // Camera rotation
GetMouseWheelMove()*-2.0f); // Move to target (zoom) GetMouseWheelMove()*-2.0f); // Move to target (zoom)
// Cycle between models on mouse click // Cycle between models on mouse click
if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) currentModel = (currentModel + 1) % MAX_VOX_FILES; if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) currentModel = (currentModel + 1) % MAX_VOX_FILES;
// Update the shader with the camera view vector (points towards { 0.0f, 0.0f, 0.0f }) // Update the shader with the camera view vector (points towards { 0.0f, 0.0f, 0.0f })
float cameraPos[3] = { camera.position.x, camera.position.y, camera.position.z }; float cameraPos[3] = { camera.position.x, camera.position.y, camera.position.z };
SetShaderValue(shader, shader.locs[SHADER_LOC_VECTOR_VIEW], cameraPos, SHADER_UNIFORM_VEC3); SetShaderValue(shader, shader.locs[SHADER_LOC_VECTOR_VIEW], cameraPos, SHADER_UNIFORM_VEC3);
// Update light values (actually, only enable/disable them) // Update light values (actually, only enable/disable them)
for (int i = 0; i < MAX_LIGHTS; i++) UpdateLightValues(shader, lights[i]); for (int i = 0; i < MAX_LIGHTS; i++) UpdateLightValues(shader, lights[i]);
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
@ -175,17 +175,17 @@ int main(void)
DrawText("- UP-DOWN-LEFT-RIGHT KEYS: MOVE CAMERA", 20, 90, 10, BLUE); DrawText("- UP-DOWN-LEFT-RIGHT KEYS: MOVE CAMERA", 20, 90, 10, BLUE);
DrawText(TextFormat("Model file: %s", GetFileName(voxFileNames[currentModel])), 10, 10, 20, GRAY); DrawText(TextFormat("Model file: %s", GetFileName(voxFileNames[currentModel])), 10, 10, 20, GRAY);
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
} }
// De-Initialization // De-Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
// Unload models data (GPU VRAM) // Unload models data (GPU VRAM)
for (int i = 0; i < MAX_VOX_FILES; i++) UnloadModel(models[i]); for (int i = 0; i < MAX_VOX_FILES; i++) UnloadModel(models[i]);
CloseWindow(); // Close window and OpenGL context CloseWindow(); // Close window and OpenGL context
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
return 0; return 0;
} }

16
examples/models/models_rotating_cube.c
View File

@ -5,7 +5,7 @@
* Example complexity rating: [★☆☆☆] 1/4 * Example complexity rating: [★☆☆☆] 1/4
* *
* Example originally created with raylib 5.6-dev, last time updated with raylib 5.6-dev * Example originally created with raylib 5.6-dev, last time updated with raylib 5.6-dev
* *
* Example contributed by Jopestpe (@jopestpe) * Example contributed by Jopestpe (@jopestpe)
* *
* Example licensed under an unmodified zlib/libpng license, which is an OSI-certified, * Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
@ -48,7 +48,7 @@ int main(void)
model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texture; model.materials[0].maps[MATERIAL_MAP_DIFFUSE].texture = texture;
float rotation = 0.0f; float rotation = 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
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -59,7 +59,7 @@ int main(void)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
rotation += 1.0f; rotation += 1.0f;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
@ -67,13 +67,13 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginMode3D(camera); BeginMode3D(camera);
// Draw model defining: position, size, rotation-axis, rotation (degrees), size, and tint-color // Draw model defining: position, size, rotation-axis, rotation (degrees), size, and tint-color
DrawModelEx(model, (Vector3){ 0.0f, 0.0f, 0.0f }, (Vector3){ 0.5f, 1.0f, 0.0f }, DrawModelEx(model, (Vector3){ 0.0f, 0.0f, 0.0f }, (Vector3){ 0.5f, 1.0f, 0.0f },
rotation, (Vector3){ 1.0f, 1.0f, 1.0f }, WHITE); rotation, (Vector3){ 1.0f, 1.0f, 1.0f }, WHITE);
DrawGrid(10, 1.0f); DrawGrid(10, 1.0f);
EndMode3D(); EndMode3D();
DrawFPS(10, 10); DrawFPS(10, 10);

2
examples/others/easings_testbed.c
View File

@ -221,7 +221,7 @@ int main(void)
} }
// NoEase function, used when "no easing" is selected for any axis // NoEase function, used when "no easing" is selected for any axis
// It just ignores all parameters besides b // It just ignores all parameters besides b
static float NoEase(float t, float b, float c, float d) static float NoEase(float t, float b, float c, float d)
{ {

6
examples/shaders/shaders_ascii_rendering.c
View File

@ -87,15 +87,15 @@ int main(void)
DrawTexture(fudesumi, 500, -30, WHITE); DrawTexture(fudesumi, 500, -30, WHITE);
DrawTextureV(raysan, circlePos, WHITE); DrawTextureV(raysan, circlePos, WHITE);
EndTextureMode(); EndTextureMode();
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginShaderMode(shader); BeginShaderMode(shader);
// Draw the scene texture (that we rendered earlier) to the screen // Draw the scene texture (that we rendered earlier) to the screen
// The shader will process every pixel of this texture // The shader will process every pixel of this texture
DrawTextureRec(target.texture, DrawTextureRec(target.texture,
(Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height }, (Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height },
(Vector2){ 0, 0 }, WHITE); (Vector2){ 0, 0 }, WHITE);
EndShaderMode(); EndShaderMode();

4
examples/shaders/shaders_basic_pbr.c
View File

@ -242,7 +242,7 @@ int main(void)
SetShaderValue(shader, emissiveColorLoc, &carEmissiveColor, SHADER_UNIFORM_VEC4); SetShaderValue(shader, emissiveColorLoc, &carEmissiveColor, SHADER_UNIFORM_VEC4);
float emissiveIntensity = 0.01f; float emissiveIntensity = 0.01f;
SetShaderValue(shader, emissiveIntensityLoc, &emissiveIntensity, SHADER_UNIFORM_FLOAT); SetShaderValue(shader, emissiveIntensityLoc, &emissiveIntensity, SHADER_UNIFORM_FLOAT);
// Set old car metallic and roughness values // Set old car metallic and roughness values
SetShaderValue(shader, metallicValueLoc, &car.materials[0].maps[MATERIAL_MAP_METALNESS].value, SHADER_UNIFORM_FLOAT); SetShaderValue(shader, metallicValueLoc, &car.materials[0].maps[MATERIAL_MAP_METALNESS].value, SHADER_UNIFORM_FLOAT);
SetShaderValue(shader, roughnessValueLoc, &car.materials[0].maps[MATERIAL_MAP_ROUGHNESS].value, SHADER_UNIFORM_FLOAT); SetShaderValue(shader, roughnessValueLoc, &car.materials[0].maps[MATERIAL_MAP_ROUGHNESS].value, SHADER_UNIFORM_FLOAT);
@ -252,7 +252,7 @@ int main(void)
// Draw spheres to show the lights positions // Draw spheres to show the lights positions
for (int i = 0; i < MAX_LIGHTS; i++) for (int i = 0; i < MAX_LIGHTS; i++)
{ {
Color lightColor = (Color){ Color lightColor = (Color){
(unsigned char)(lights[i].color[0]*255), (unsigned char)(lights[i].color[0]*255),
(unsigned char)(lights[i].color[1] * 255), (unsigned char)(lights[i].color[1] * 255),
(unsigned char)(lights[i].color[2] * 255), (unsigned char)(lights[i].color[2] * 255),

6
examples/shaders/shaders_lightmap_rendering.c
View File

@ -124,7 +124,7 @@ int main(void)
); );
BeginBlendMode(BLEND_ALPHA); BeginBlendMode(BLEND_ALPHA);
EndTextureMode(); EndTextureMode();
// NOTE: To enable trilinear filtering we need mipmaps available for texture // NOTE: To enable trilinear filtering we need mipmaps available for texture
GenTextureMipmaps(&lightmap.texture); GenTextureMipmaps(&lightmap.texture);
SetTextureFilter(lightmap.texture, TEXTURE_FILTER_TRILINEAR); SetTextureFilter(lightmap.texture, TEXTURE_FILTER_TRILINEAR);
@ -143,7 +143,7 @@ int main(void)
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginMode3D(camera); BeginMode3D(camera);
@ -155,7 +155,7 @@ int main(void)
(Vector2){ 0.0, 0.0 }, 0.0, WHITE); (Vector2){ 0.0, 0.0 }, 0.0, WHITE);
DrawText(TextFormat("LIGHTMAP: %ix%i pixels", MAP_SIZE, MAP_SIZE), GetRenderWidth() - 130, 20 + MAP_SIZE*8, 10, GREEN); DrawText(TextFormat("LIGHTMAP: %ix%i pixels", MAP_SIZE, MAP_SIZE), GetRenderWidth() - 130, 20 + MAP_SIZE*8, 10, GREEN);
DrawFPS(10, 10); DrawFPS(10, 10);
EndDrawing(); EndDrawing();

22
examples/shaders/shaders_shadowmap_rendering.c
View File

@ -45,7 +45,7 @@ int main(void)
// Shadows are a HUGE topic, and this example shows an extremely simple implementation of the shadowmapping algorithm, // Shadows are a HUGE topic, and this example shows an extremely simple implementation of the shadowmapping algorithm,
// which is the industry standard for shadows. This algorithm can be extended in a ridiculous number of ways to improve // which is the industry standard for shadows. This algorithm can be extended in a ridiculous number of ways to improve
// realism and also adapt it for different scenes. This is pretty much the simplest possible implementation // realism and also adapt it for different scenes. This is pretty much the simplest possible implementation
SetConfigFlags(FLAG_MSAA_4X_HINT); SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shadowmap rendering"); InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shadowmap rendering");
@ -59,7 +59,7 @@ int main(void)
Shader shadowShader = LoadShader(TextFormat("resources/shaders/glsl%i/shadowmap.vs", GLSL_VERSION), Shader shadowShader = LoadShader(TextFormat("resources/shaders/glsl%i/shadowmap.vs", GLSL_VERSION),
TextFormat("resources/shaders/glsl%i/shadowmap.fs", GLSL_VERSION)); TextFormat("resources/shaders/glsl%i/shadowmap.fs", GLSL_VERSION));
shadowShader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shadowShader, "viewPos"); shadowShader.locs[SHADER_LOC_VECTOR_VIEW] = GetShaderLocation(shadowShader, "viewPos");
Vector3 lightDir = Vector3Normalize((Vector3){ 0.35f, -1.0f, -0.35f }); Vector3 lightDir = Vector3Normalize((Vector3){ 0.35f, -1.0f, -0.35f });
Color lightColor = WHITE; Color lightColor = WHITE;
Vector4 lightColorNormalized = ColorNormalize(lightColor); Vector4 lightColorNormalized = ColorNormalize(lightColor);
@ -83,7 +83,7 @@ int main(void)
ModelAnimation *robotAnimations = LoadModelAnimations("resources/models/robot.glb", &animCount); ModelAnimation *robotAnimations = LoadModelAnimations("resources/models/robot.glb", &animCount);
RenderTexture2D shadowMap = LoadShadowmapRenderTexture(SHADOWMAP_RESOLUTION, SHADOWMAP_RESOLUTION); RenderTexture2D shadowMap = LoadShadowmapRenderTexture(SHADOWMAP_RESOLUTION, SHADOWMAP_RESOLUTION);
// For the shadowmapping algorithm, we will be rendering everything from the light's point of view // For the shadowmapping algorithm, we will be rendering everything from the light's point of view
Camera3D lightCamera = { 0 }; Camera3D lightCamera = { 0 };
lightCamera.position = Vector3Scale(lightDir, -15.0f); lightCamera.position = Vector3Scale(lightDir, -15.0f);
@ -91,9 +91,9 @@ int main(void)
lightCamera.projection = CAMERA_ORTHOGRAPHIC; // Use an orthographic projection for directional lights lightCamera.projection = CAMERA_ORTHOGRAPHIC; // Use an orthographic projection for directional lights
lightCamera.up = (Vector3){ 0.0f, 1.0f, 0.0f }; lightCamera.up = (Vector3){ 0.0f, 1.0f, 0.0f };
lightCamera.fovy = 20.0f; lightCamera.fovy = 20.0f;
int frameCounter = 0; int frameCounter = 0;
// Store the light matrices // Store the light matrices
Matrix lightView = { 0 }; Matrix lightView = { 0 };
Matrix lightProj = { 0 }; Matrix lightProj = { 0 };
@ -136,7 +136,7 @@ int main(void)
{ {
if (lightDir.z > -0.6f) lightDir.z -= cameraSpeed*60.0f*deltaTime; if (lightDir.z > -0.6f) lightDir.z -= cameraSpeed*60.0f*deltaTime;
} }
lightDir = Vector3Normalize(lightDir); lightDir = Vector3Normalize(lightDir);
lightCamera.position = Vector3Scale(lightDir, -15.0f); lightCamera.position = Vector3Scale(lightDir, -15.0f);
SetShaderValue(shadowShader, lightDirLoc, &lightDir, SHADER_UNIFORM_VEC3); SetShaderValue(shadowShader, lightDirLoc, &lightDir, SHADER_UNIFORM_VEC3);
@ -151,13 +151,13 @@ int main(void)
// to determine whether a given point is "visible" to the light // to determine whether a given point is "visible" to the light
BeginTextureMode(shadowMap); BeginTextureMode(shadowMap);
ClearBackground(WHITE); ClearBackground(WHITE);
BeginMode3D(lightCamera); BeginMode3D(lightCamera);
lightView = rlGetMatrixModelview(); lightView = rlGetMatrixModelview();
lightProj = rlGetMatrixProjection(); lightProj = rlGetMatrixProjection();
DrawScene(cube, robot); DrawScene(cube, robot);
EndMode3D(); EndMode3D();
EndTextureMode(); EndTextureMode();
lightViewProj = MatrixMultiply(lightView, lightProj); lightViewProj = MatrixMultiply(lightView, lightProj);
@ -167,7 +167,7 @@ int main(void)
SetShaderValueMatrix(shadowShader, lightVPLoc, lightViewProj); SetShaderValueMatrix(shadowShader, lightVPLoc, lightViewProj);
rlEnableShader(shadowShader.id); rlEnableShader(shadowShader.id);
rlActiveTextureSlot(textureActiveSlot); rlActiveTextureSlot(textureActiveSlot);
rlEnableTexture(shadowMap.depth.id); rlEnableTexture(shadowMap.depth.id);
rlSetUniform(shadowMapLoc, &textureActiveSlot, SHADER_UNIFORM_INT, 1); rlSetUniform(shadowMapLoc, &textureActiveSlot, SHADER_UNIFORM_INT, 1);
@ -178,7 +178,7 @@ int main(void)
DrawText("Use the arrow keys to rotate the light!", 10, 10, 30, RED); DrawText("Use the arrow keys to rotate the light!", 10, 10, 30, RED);
DrawText("Shadows in raylib using the shadowmapping algorithm!", screenWidth - 280, screenHeight - 20, 10, GRAY); DrawText("Shadows in raylib using the shadowmapping algorithm!", screenWidth - 280, screenHeight - 20, 10, GRAY);
EndDrawing(); EndDrawing();
if (IsKeyPressed(KEY_F)) TakeScreenshot("shaders_shadowmap.png"); if (IsKeyPressed(KEY_F)) TakeScreenshot("shaders_shadowmap.png");
@ -200,7 +200,7 @@ int main(void)
} }
// Load render texture for shadowmap projection // Load render texture for shadowmap projection
// NOTE: Load framebuffer with only a texture depth attachment, // NOTE: Load framebuffer with only a texture depth attachment,
// no color attachment required for shadowmap // no color attachment required for shadowmap
static RenderTexture2D LoadShadowmapRenderTexture(int width, int height) static RenderTexture2D LoadShadowmapRenderTexture(int width, int height)
{ {

4
examples/shaders/shaders_spotlight_rendering.c
View File

@ -239,7 +239,7 @@ int main(void)
static void ResetStar(Star *star) static void ResetStar(Star *star)
{ {
star->position = (Vector2){ GetScreenWidth()/2.0f, GetScreenHeight()/2.0f }; star->position = (Vector2){ GetScreenWidth()/2.0f, GetScreenHeight()/2.0f };
star->speed.x = (float)GetRandomValue(-1000, 1000)/100.0f; star->speed.x = (float)GetRandomValue(-1000, 1000)/100.0f;
star->speed.y = (float)GetRandomValue(-1000, 1000)/100.0f; star->speed.y = (float)GetRandomValue(-1000, 1000)/100.0f;
@ -247,7 +247,7 @@ static void ResetStar(Star *star)
{ {
star->speed.x = (float)GetRandomValue(-1000, 1000)/100.0f; star->speed.x = (float)GetRandomValue(-1000, 1000)/100.0f;
star->speed.y = (float)GetRandomValue(-1000, 1000)/100.0f; star->speed.y = (float)GetRandomValue(-1000, 1000)/100.0f;
} }
star->position = Vector2Add(star->position, Vector2Multiply(star->speed, (Vector2){ 8.0f, 8.0f })); star->position = Vector2Add(star->position, Vector2Multiply(star->speed, (Vector2){ 8.0f, 8.0f }));
} }

10
examples/shapes/shapes_bouncing_ball.c
View File

@ -7,7 +7,7 @@
* Example originally created with raylib 2.5, last time updated with raylib 2.5 * Example originally created with raylib 2.5, last time updated with raylib 2.5
* *
* Example contributed by Ramon Santamaria (@raysan5), reviewed by Jopestpe (@jopestpe) * Example contributed by Ramon Santamaria (@raysan5), reviewed by Jopestpe (@jopestpe)
* *
* Example licensed under an unmodified zlib/libpng license, which is an OSI-certified, * Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
* BSD-like license that allows static linking with closed source software * BSD-like license that allows static linking with closed source software
* *
@ -49,14 +49,14 @@ int main(void)
//----------------------------------------------------- //-----------------------------------------------------
if (IsKeyPressed(KEY_G)) useGravity = !useGravity; if (IsKeyPressed(KEY_G)) useGravity = !useGravity;
if (IsKeyPressed(KEY_SPACE)) pause = !pause; if (IsKeyPressed(KEY_SPACE)) pause = !pause;
if (!pause) if (!pause)
{ {
ballPosition.x += ballSpeed.x; ballPosition.x += ballSpeed.x;
ballPosition.y += ballSpeed.y; ballPosition.y += ballSpeed.y;
if (useGravity) ballSpeed.y += gravity; if (useGravity) ballSpeed.y += gravity;
// Check walls collision for bouncing // Check walls collision for bouncing
if ((ballPosition.x >= (GetScreenWidth() - ballRadius)) || (ballPosition.x <= ballRadius)) ballSpeed.x *= -1.0f; if ((ballPosition.x >= (GetScreenWidth() - ballRadius)) || (ballPosition.x <= ballRadius)) ballSpeed.x *= -1.0f;
if ((ballPosition.y >= (GetScreenHeight() - ballRadius)) || (ballPosition.y <= ballRadius)) ballSpeed.y *= -0.95f; if ((ballPosition.y >= (GetScreenHeight() - ballRadius)) || (ballPosition.y <= ballRadius)) ballSpeed.y *= -0.95f;
@ -72,7 +72,7 @@ int main(void)
DrawCircleV(ballPosition, (float)ballRadius, MAROON); DrawCircleV(ballPosition, (float)ballRadius, MAROON);
DrawText("PRESS SPACE to PAUSE BALL MOVEMENT", 10, GetScreenHeight() - 25, 20, LIGHTGRAY); DrawText("PRESS SPACE to PAUSE BALL MOVEMENT", 10, GetScreenHeight() - 25, 20, LIGHTGRAY);
if (useGravity) DrawText("GRAVITY: ON (Press G to disable)", 10, GetScreenHeight() - 50, 20, DARKGREEN); if (useGravity) DrawText("GRAVITY: ON (Press G to disable)", 10, GetScreenHeight() - 50, 20, DARKGREEN);
else DrawText("GRAVITY: OFF (Press G to enable)", 10, GetScreenHeight() - 50, 20, RED); else DrawText("GRAVITY: OFF (Press G to enable)", 10, GetScreenHeight() - 50, 20, RED);
@ -80,7 +80,7 @@ int main(void)
if (pause && ((framesCounter/30)%2)) DrawText("PAUSED", 350, 200, 30, GRAY); if (pause && ((framesCounter/30)%2)) DrawText("PAUSED", 350, 200, 30, GRAY);
DrawFPS(10, 10); DrawFPS(10, 10);
EndDrawing(); EndDrawing();
//----------------------------------------------------- //-----------------------------------------------------
} }

76
examples/shapes/shapes_clock_of_clocks.c
View File

@ -35,14 +35,14 @@ int main(void)
SetConfigFlags(FLAG_MSAA_4X_HINT); SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - clock of clocks"); InitWindow(screenWidth, screenHeight, "raylib [shapes] example - clock of clocks");
const Color bgColor = ColorLerp(DARKBLUE, BLACK, 0.75f); const Color bgColor = ColorLerp(DARKBLUE, BLACK, 0.75f);
const Color handsColor = ColorLerp(YELLOW, RAYWHITE, .25f); const Color handsColor = ColorLerp(YELLOW, RAYWHITE, .25f);
const float clockFaceSize = 24; const float clockFaceSize = 24;
const float clockFaceSpacing = 8.0f; const float clockFaceSpacing = 8.0f;
const float sectionSpacing = 16.0f; const float sectionSpacing = 16.0f;
const Vector2 TL = (Vector2){ 0.0f, 90.0f }; // Top-left corner const Vector2 TL = (Vector2){ 0.0f, 90.0f }; // Top-left corner
const Vector2 TR = (Vector2){ 90.0f, 180.0f }; // Top-right corner const Vector2 TR = (Vector2){ 90.0f, 180.0f }; // Top-right corner
const Vector2 BR = (Vector2){ 180.0f, 270.0f }; // Bottom-right corner const Vector2 BR = (Vector2){ 180.0f, 270.0f }; // Bottom-right corner
@ -50,7 +50,7 @@ int main(void)
const Vector2 HH = (Vector2){ 0.0f, 180.0f }; // Horizontal line const Vector2 HH = (Vector2){ 0.0f, 180.0f }; // Horizontal line
const Vector2 VV = (Vector2){ 90.0f, 270.0f }; // Vertical line const Vector2 VV = (Vector2){ 90.0f, 270.0f }; // Vertical line
const Vector2 ZZ = (Vector2){ 135.0f, 135.0f }; // Not relevant const Vector2 ZZ = (Vector2){ 135.0f, 135.0f }; // Not relevant
const Vector2 digitAngles[10][24] = { const Vector2 digitAngles[10][24] = {
/* 0 */ { TL,HH,HH,TR, /* */ VV,TL,TR,VV,/* */ VV,VV,VV,VV,/* */ VV,VV,VV,VV,/* */ VV,BL,BR,VV,/* */ BL,HH,HH,BR }, /* 0 */ { TL,HH,HH,TR, /* */ VV,TL,TR,VV,/* */ VV,VV,VV,VV,/* */ VV,VV,VV,VV,/* */ VV,BL,BR,VV,/* */ BL,HH,HH,BR },
/* 1 */ { TL,HH,TR,ZZ, /* */ BL,TR,VV,ZZ,/* */ ZZ,VV,VV,ZZ,/* */ ZZ,VV,VV,ZZ,/* */ TL,BR,BL,TR,/* */ BL,HH,HH,BR }, /* 1 */ { TL,HH,TR,ZZ, /* */ BL,TR,VV,ZZ,/* */ ZZ,VV,VV,ZZ,/* */ ZZ,VV,VV,ZZ,/* */ TL,BR,BL,TR,/* */ BL,HH,HH,BR },
@ -65,21 +65,21 @@ int main(void)
}; };
// Time for the hands to move to the new position (in seconds); this must be <1s // Time for the hands to move to the new position (in seconds); this must be <1s
const float handsMoveDuration = .5f; const float handsMoveDuration = .5f;
// We store the previous seconds value so we can see if the time has changed // We store the previous seconds value so we can see if the time has changed
int prevSeconds = -1; int prevSeconds = -1;
// This represents the real position where the hands are right now // This represents the real position where the hands are right now
Vector2 currentAngles[6][24] = { 0 }; Vector2 currentAngles[6][24] = { 0 };
// This is the position where the hands were moving from // This is the position where the hands were moving from
Vector2 srcAngles[6][24] = { 0 }; Vector2 srcAngles[6][24] = { 0 };
// This is the position where the hands are moving to // This is the position where the hands are moving to
Vector2 dstAngles[6][24] = { 0 }; Vector2 dstAngles[6][24] = { 0 };
// Current animation timer // Current animation timer
float handsMoveTimer = 0.0f; float handsMoveTimer = 0.0f;
// 12 or 24 hour mode // 12 or 24 hour mode
int hourMode = 24; int hourMode = 24;
@ -91,32 +91,32 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Get the current time // Get the current time
time_t rawtime; time_t rawtime;
struct tm *timeinfo; struct tm *timeinfo;
time(&rawtime); time(&rawtime);
timeinfo = localtime(&rawtime); timeinfo = localtime(&rawtime);
if (timeinfo->tm_sec != prevSeconds) { if (timeinfo->tm_sec != prevSeconds) {
// The time has changed, so we need to move the hands to the new positions // The time has changed, so we need to move the hands to the new positions
prevSeconds = timeinfo->tm_sec; prevSeconds = timeinfo->tm_sec;
// Format the current time so we can access the individual digits // Format the current time so we can access the individual digits
const char *clockDigits = TextFormat("%02d%02d%02d", timeinfo->tm_hour % hourMode, timeinfo->tm_min, timeinfo->tm_sec); const char *clockDigits = TextFormat("%02d%02d%02d", timeinfo->tm_hour % hourMode, timeinfo->tm_min, timeinfo->tm_sec);
// Fetch where we want all the hands to be // Fetch where we want all the hands to be
for (int digit = 0; digit < 6; digit++) { for (int digit = 0; digit < 6; digit++) {
for (int cell = 0; cell < 24; cell++) { for (int cell = 0; cell < 24; cell++) {
srcAngles[digit][cell] = currentAngles[digit][cell]; srcAngles[digit][cell] = currentAngles[digit][cell];
dstAngles[digit][cell] = digitAngles[ clockDigits[digit] - '0' ][cell]; dstAngles[digit][cell] = digitAngles[ clockDigits[digit] - '0' ][cell];
// Quick exception for 12h mode // Quick exception for 12h mode
if (digit == 0 && hourMode == 12 && clockDigits[0] == '0') { if (digit == 0 && hourMode == 12 && clockDigits[0] == '0') {
dstAngles[digit][cell] = ZZ; dstAngles[digit][cell] = ZZ;
} }
if (srcAngles[digit][cell].x > dstAngles[digit][cell].x) { if (srcAngles[digit][cell].x > dstAngles[digit][cell].x) {
srcAngles[digit][cell].x -= 360.0f; srcAngles[digit][cell].x -= 360.0f;
} }
@ -125,43 +125,43 @@ int main(void)
} }
} }
} }
// Reset the timer // Reset the timer
handsMoveTimer = -GetFrameTime(); handsMoveTimer = -GetFrameTime();
} }
// Now let's animate all the hands if we need to // Now let's animate all the hands if we need to
if (handsMoveTimer < handsMoveDuration) { if (handsMoveTimer < handsMoveDuration) {
// Increase the timer but don't go above the maximum // Increase the timer but don't go above the maximum
handsMoveTimer = Clamp(handsMoveTimer + GetFrameTime(), 0, handsMoveDuration); handsMoveTimer = Clamp(handsMoveTimer + GetFrameTime(), 0, handsMoveDuration);
// Calculate the % completion of the animation // Calculate the % completion of the animation
float t = handsMoveTimer / handsMoveDuration; float t = handsMoveTimer / handsMoveDuration;
// A little cheeky smoothstep // A little cheeky smoothstep
t = t * t * (3.0f - 2.0f * t); t = t * t * (3.0f - 2.0f * t);
for (int digit = 0; digit < 6; digit++) { for (int digit = 0; digit < 6; digit++) {
for (int cell = 0; cell < 24; cell++) { for (int cell = 0; cell < 24; cell++) {
currentAngles[digit][cell].x = Lerp(srcAngles[digit][cell].x, dstAngles[digit][cell].x, t); currentAngles[digit][cell].x = Lerp(srcAngles[digit][cell].x, dstAngles[digit][cell].x, t);
currentAngles[digit][cell].y = Lerp(srcAngles[digit][cell].y, dstAngles[digit][cell].y, t); currentAngles[digit][cell].y = Lerp(srcAngles[digit][cell].y, dstAngles[digit][cell].y, t);
} }
} }
if (handsMoveTimer == handsMoveDuration) { if (handsMoveTimer == handsMoveDuration) {
// The animation has now finished // The animation has now finished
} }
} }
// Handle input // Handle input
// Toggle between 12 and 24 hour mode with space // Toggle between 12 and 24 hour mode with space
if (IsKeyPressed(KEY_SPACE)) { if (IsKeyPressed(KEY_SPACE)) {
hourMode = 36 - hourMode; hourMode = 36 - hourMode;
} }
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -169,13 +169,13 @@ int main(void)
BeginDrawing(); BeginDrawing();
ClearBackground(bgColor); ClearBackground(bgColor);
DrawText(TextFormat("%d-h mode, space to change", hourMode), 10, 30, 20, RAYWHITE); DrawText(TextFormat("%d-h mode, space to change", hourMode), 10, 30, 20, RAYWHITE);
float xOffset = 4.0f; float xOffset = 4.0f;
for (int digit = 0; digit < 6; digit++) { for (int digit = 0; digit < 6; digit++) {
for (int row = 0; row < 6; row++) { for (int row = 0; row < 6; row++) {
for (int col = 0; col < 4; col++) { for (int col = 0; col < 4; col++) {
Vector2 centre = (Vector2){ Vector2 centre = (Vector2){
@ -183,7 +183,7 @@ int main(void)
100 + row*(clockFaceSize+clockFaceSpacing) + clockFaceSize * .5f 100 + row*(clockFaceSize+clockFaceSpacing) + clockFaceSize * .5f
}; };
DrawRing(centre, clockFaceSize * 0.5f - 2.0f, clockFaceSize * 0.5f, 0, 360, 24, DARKGRAY); DrawRing(centre, clockFaceSize * 0.5f - 2.0f, clockFaceSize * 0.5f, 0, 360, 24, DARKGRAY);
// Big hand // Big hand
DrawRectanglePro( DrawRectanglePro(
(Rectangle){centre.x, centre.y, clockFaceSize*.5f+4.0f, 4.0f}, (Rectangle){centre.x, centre.y, clockFaceSize*.5f+4.0f, 4.0f},
@ -191,7 +191,7 @@ int main(void)
currentAngles[digit][row*4+col].x, currentAngles[digit][row*4+col].x,
handsColor handsColor
); );
// Little hand // Little hand
DrawRectanglePro( DrawRectanglePro(
(Rectangle){centre.x, centre.y, clockFaceSize*.5f+2.0f, 4.0f}, (Rectangle){centre.x, centre.y, clockFaceSize*.5f+2.0f, 4.0f},
@ -201,20 +201,20 @@ int main(void)
); );
} }
} }
xOffset += (clockFaceSize+clockFaceSpacing) * 4; xOffset += (clockFaceSize+clockFaceSpacing) * 4;
if (digit % 2 == 1) { if (digit % 2 == 1) {
DrawRing((Vector2){xOffset + 4.0f, 160.0f}, 6.0f, 8.0f, 0.0f, 360.0f, 24, handsColor); DrawRing((Vector2){xOffset + 4.0f, 160.0f}, 6.0f, 8.0f, 0.0f, 360.0f, 24, handsColor);
DrawRing((Vector2){xOffset + 4.0f, 225.0f}, 6.0f, 8.0f, 0.0f, 360.0f, 24, handsColor); DrawRing((Vector2){xOffset + 4.0f, 225.0f}, 6.0f, 8.0f, 0.0f, 360.0f, 24, handsColor);
xOffset += sectionSpacing; xOffset += sectionSpacing;
} }
} }
DrawFPS(10, 10); DrawFPS(10, 10);
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------

28
examples/shapes/shapes_digital_clock.c
View File

@ -116,7 +116,7 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// Draw clock in selected mode // Draw clock in selected mode
if (clockMode == CLOCK_ANALOG) DrawClockAnalog(clock, (Vector2){ 400, 240 }); if (clockMode == CLOCK_ANALOG) DrawClockAnalog(clock, (Vector2){ 400, 240 });
else if (clockMode == CLOCK_DIGITAL) else if (clockMode == CLOCK_DIGITAL)
{ {
DrawClockDigital(clock, (Vector2){ 30, 60 }); DrawClockDigital(clock, (Vector2){ 30, 60 });
@ -128,7 +128,7 @@ int main(void)
DrawText(clockTime, GetScreenWidth()/2 - MeasureText(clockTime, 150)/2, 300, 150, BLACK); DrawText(clockTime, GetScreenWidth()/2 - MeasureText(clockTime, 150)/2, 300, 150, BLACK);
} }
DrawText(TextFormat("Press [SPACE] to switch clock mode: %s", DrawText(TextFormat("Press [SPACE] to switch clock mode: %s",
(clockMode == CLOCK_DIGITAL)? "DIGITAL CLOCK" : "ANALOGUE CLOCK"), 10, 10, 20, DARKGRAY); (clockMode == CLOCK_DIGITAL)? "DIGITAL CLOCK" : "ANALOGUE CLOCK"), 10, 10, 20, DARKGRAY);
EndDrawing(); EndDrawing();
@ -183,13 +183,13 @@ static void DrawClockAnalog(Clock clock, Vector2 position)
// Draw clock minutes/seconds lines // Draw clock minutes/seconds lines
for (int i = 0; i < 60; i++) for (int i = 0; i < 60; i++)
{ {
DrawLineEx((Vector2){ position.x + (clock.second.length + ((i%5)? 10 : 6))*cosf((6.0f*i - 90.0f)*DEG2RAD), DrawLineEx((Vector2){ position.x + (clock.second.length + ((i%5)? 10 : 6))*cosf((6.0f*i - 90.0f)*DEG2RAD),
position.y + (clock.second.length + ((i%5)? 10 : 6))*sinf((6.0f*i - 90.0f)*DEG2RAD) }, position.y + (clock.second.length + ((i%5)? 10 : 6))*sinf((6.0f*i - 90.0f)*DEG2RAD) },
(Vector2){ position.x + (clock.second.length + 20)*cosf((6.0f*i - 90.0f)*DEG2RAD), (Vector2){ position.x + (clock.second.length + 20)*cosf((6.0f*i - 90.0f)*DEG2RAD),
position.y + (clock.second.length + 20)*sinf((6.0f*i - 90.0f)*DEG2RAD) }, ((i%5)? 1.0f : 3.0f), DARKGRAY); position.y + (clock.second.length + 20)*sinf((6.0f*i - 90.0f)*DEG2RAD) }, ((i%5)? 1.0f : 3.0f), DARKGRAY);
// Draw seconds numbers // Draw seconds numbers
//DrawText(TextFormat("%02i", i), centerPosition.x + (clock.second.length + 50)*cosf((6.0f*i - 90.0f)*DEG2RAD) - 10/2, //DrawText(TextFormat("%02i", i), centerPosition.x + (clock.second.length + 50)*cosf((6.0f*i - 90.0f)*DEG2RAD) - 10/2,
// centerPosition.y + (clock.second.length + 50)*sinf((6.0f*i - 90.0f)*DEG2RAD) - 10/2, 10, GRAY); // centerPosition.y + (clock.second.length + 50)*sinf((6.0f*i - 90.0f)*DEG2RAD) - 10/2, 10, GRAY);
} }
@ -256,25 +256,25 @@ static void Draw7SDisplay(Vector2 position, char segments, Color colorOn, Color
float offsetYAdjust = segmentThick*0.3f; // HACK: Adjust gap space between segment limits float offsetYAdjust = segmentThick*0.3f; // HACK: Adjust gap space between segment limits
// Segment A // Segment A
DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + segmentThick }, DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + segmentThick },
segmentLen, segmentThick, false, (segments & 0b00000001)? colorOn : colorOff); segmentLen, segmentThick, false, (segments & 0b00000001)? colorOn : colorOff);
// Segment B // Segment B
DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust }, DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust },
segmentLen, segmentThick, true, (segments & 0b00000010)? colorOn : colorOff); segmentLen, segmentThick, true, (segments & 0b00000010)? colorOn : colorOff);
// Segment C // Segment C
DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust }, DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust },
segmentLen, segmentThick, true, (segments & 0b00000100)? colorOn : colorOff); segmentLen, segmentThick, true, (segments & 0b00000100)? colorOn : colorOff);
// Segment D // Segment D
DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 5*segmentThick + 2*segmentLen - 4*offsetYAdjust }, DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 5*segmentThick + 2*segmentLen - 4*offsetYAdjust },
segmentLen, segmentThick, false, (segments & 0b00001000)? colorOn : colorOff); segmentLen, segmentThick, false, (segments & 0b00001000)? colorOn : colorOff);
// Segment E // Segment E
DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust }, DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 4*segmentThick + segmentLen + segmentLen/2.0f - 3*offsetYAdjust },
segmentLen, segmentThick, true, (segments & 0b00010000)? colorOn : colorOff); segmentLen, segmentThick, true, (segments & 0b00010000)? colorOn : colorOff);
// Segment F // Segment F
DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust }, DrawDisplaySegment((Vector2){ position.x + segmentThick/2.0f, position.y + 2*segmentThick + segmentLen/2.0f - offsetYAdjust },
segmentLen, segmentThick, true, (segments & 0b00100000)? colorOn : colorOff); segmentLen, segmentThick, true, (segments & 0b00100000)? colorOn : colorOff);
// Segment G // Segment G
DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 3*segmentThick + segmentLen - 2*offsetYAdjust }, DrawDisplaySegment((Vector2){ position.x + segmentThick + segmentLen/2.0f, position.y + 3*segmentThick + segmentLen - 2*offsetYAdjust },
segmentLen, segmentThick, false, (segments & 0b01000000)? colorOn : colorOff); segmentLen, segmentThick, false, (segments & 0b01000000)? colorOn : colorOff);
} }

18
examples/shapes/shapes_kaleidoscope.c
View File

@ -51,13 +51,13 @@ int main(void)
Vector2 prevMousePos = { 0 }; Vector2 prevMousePos = { 0 };
Vector2 scaleVector = { 1.0f, -1.0f }; Vector2 scaleVector = { 1.0f, -1.0f };
Vector2 offset = { (float)screenWidth/2.0f, (float)screenHeight/2.0f }; Vector2 offset = { (float)screenWidth/2.0f, (float)screenHeight/2.0f };
Camera2D camera = { 0 }; Camera2D camera = { 0 };
camera.target = (Vector2){ 0 }; camera.target = (Vector2){ 0 };
camera.offset = offset; camera.offset = offset;
camera.rotation = 0.0f; camera.rotation = 0.0f;
camera.zoom = 1.0f; camera.zoom = 1.0f;
int lineCounter = 0; int lineCounter = 0;
SetTargetFPS(20); SetTargetFPS(20);
@ -70,10 +70,10 @@ int main(void)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
prevMousePos = mousePos; prevMousePos = mousePos;
mousePos = GetMousePosition(); mousePos = GetMousePosition();
Vector2 lineStart = Vector2Subtract(mousePos, offset); Vector2 lineStart = Vector2Subtract(mousePos, offset);
Vector2 lineEnd = Vector2Subtract(prevMousePos, offset); Vector2 lineEnd = Vector2Subtract(prevMousePos, offset);
if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) if (IsMouseButtonDown(MOUSE_LEFT_BUTTON))
{ {
for (int s = 0; (s < symmetry) && (lineCounter < (MAX_DRAW_LINES - 1)); s++) for (int s = 0; (s < symmetry) && (lineCounter < (MAX_DRAW_LINES - 1)); s++)
@ -88,7 +88,7 @@ int main(void)
// Store reflective line // Store reflective line
lines[lineCounter + 1].start = Vector2Multiply(lineStart, scaleVector); lines[lineCounter + 1].start = Vector2Multiply(lineStart, scaleVector);
lines[lineCounter + 1].end = Vector2Multiply(lineEnd, scaleVector); lines[lineCounter + 1].end = Vector2Multiply(lineEnd, scaleVector);
lineCounter += 2; lineCounter += 2;
} }
} }
@ -97,9 +97,9 @@ int main(void)
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
BeginMode2D(camera); BeginMode2D(camera);
for (int s = 0; s < symmetry; s++) for (int s = 0; s < symmetry; s++)
{ {
@ -110,10 +110,10 @@ int main(void)
} }
} }
EndMode2D(); EndMode2D();
DrawText(TextFormat("LINES: %i/%i", lineCounter, MAX_DRAW_LINES), 10, screenHeight - 30, 20, MAROON); DrawText(TextFormat("LINES: %i/%i", lineCounter, MAX_DRAW_LINES), 10, screenHeight - 30, 20, MAROON);
DrawFPS(10, 10); DrawFPS(10, 10);
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
} }

181
examples/shapes/shapes_lines_drawing.c
View File

@ -16,6 +16,7 @@
********************************************************************************************/ ********************************************************************************************/
#include "raylib.h" #include "raylib.h"
#include "raymath.h" #include "raymath.h"
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
@ -23,122 +24,114 @@
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------
int main(void) int main(void)
{ {
// Initialization // Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - lines drawing"); InitWindow(screenWidth, screenHeight, "raylib [shapes] example - lines drawing");
// Hint text that shows before you click the screen // Hint text that shows before you click the screen
bool startText = true; bool startText = true;
// The mouse's position on the previous frame // The mouse's position on the previous frame
Vector2 mousePositionPrevious = GetMousePosition(); Vector2 mousePositionPrevious = GetMousePosition();
// The canvas to draw lines on // The canvas to draw lines on
RenderTexture canvas = LoadRenderTexture(screenWidth, screenHeight); RenderTexture canvas = LoadRenderTexture(screenWidth, screenHeight);
// The background color of the canvas // The line's thickness
const Color backgroundColor = RAYWHITE; float lineThickness = 8.0f;
// The lines hue (in HSV, from 0-360)
float lineHue = 0.0f;
// The line's thickness // Clear the canvas to the background color
float lineThickness = 8.0f; BeginTextureMode(canvas);
// The lines hue (in HSV, from 0-360) ClearBackground(RAYWHITE);
float lineHue = 0.0f; EndTextureMode();
// Clear the canvas to the background color
BeginTextureMode(canvas);
ClearBackground(backgroundColor);
EndTextureMode();
SetTargetFPS(60); SetTargetFPS(60);
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
// Main game loop // Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key while (!WindowShouldClose()) // Detect window close button or ESC key
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Disable the hint text once the user clicks // Disable the hint text once the user clicks
if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && startText) startText = false; if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT) && startText) startText = false;
// Clear the canvas when the user middle-clicks // Clear the canvas when the user middle-clicks
if (IsMouseButtonPressed(MOUSE_BUTTON_MIDDLE)) if (IsMouseButtonPressed(MOUSE_BUTTON_MIDDLE))
{ {
BeginTextureMode(canvas); BeginTextureMode(canvas);
ClearBackground(backgroundColor); ClearBackground(RAYWHITE);
EndTextureMode(); EndTextureMode();
} }
// Store whether the left and right buttons are down // Store whether the left and right buttons are down
bool leftButtonDown = IsMouseButtonDown(MOUSE_BUTTON_LEFT); bool leftButtonDown = IsMouseButtonDown(MOUSE_BUTTON_LEFT);
bool rightButtonDown = IsMouseButtonDown(MOUSE_BUTTON_RIGHT); bool rightButtonDown = IsMouseButtonDown(MOUSE_BUTTON_RIGHT);
if (leftButtonDown || rightButtonDown) if (leftButtonDown || rightButtonDown)
{ {
// The color for the line // The color for the line
Color drawColor = WHITE; Color drawColor = WHITE;
if (leftButtonDown) if (leftButtonDown)
{ {
// Increase the hue value by the distance our cursor has moved since the last frame (divided by 3) // Increase the hue value by the distance our cursor has moved since the last frame (divided by 3)
lineHue += Vector2Distance(mousePositionPrevious, GetMousePosition())/3.0f; lineHue += Vector2Distance(mousePositionPrevious, GetMousePosition())/3.0f;
// While the hue is >=360, subtract it to bring it down into the range 0-360 // While the hue is >=360, subtract it to bring it down into the range 0-360
// This is more visually accurate than resetting to zero // This is more visually accurate than resetting to zero
while (lineHue >= 360.0f) lineHue -= 360.0f; while (lineHue >= 360.0f) lineHue -= 360.0f;
// Create the final color // Create the final color
drawColor = ColorFromHSV(lineHue, 1.0f, 1.0f); drawColor = ColorFromHSV(lineHue, 1.0f, 1.0f);
} }
else if (rightButtonDown) else if (rightButtonDown) drawColor = RAYWHITE; // Use the background color as an "eraser"
{
// Use the background color as an "eraser"
drawColor = backgroundColor;
}
// Draw the line onto the canvas // Draw the line onto the canvas
BeginTextureMode(canvas); BeginTextureMode(canvas);
// Circles act as "caps", smoothing corners
// Circles act as "caps", smoothing corners DrawCircleV(mousePositionPrevious, lineThickness/2.0f, drawColor);
DrawCircleV(mousePositionPrevious, lineThickness/2.0f, drawColor); DrawCircleV(GetMousePosition(), lineThickness/2.0f, drawColor);
DrawCircleV(GetMousePosition(), lineThickness/2.0f, drawColor); DrawLineEx(mousePositionPrevious, GetMousePosition(), lineThickness, drawColor);
DrawLineEx(mousePositionPrevious, GetMousePosition(), lineThickness, drawColor); EndTextureMode();
}
EndTextureMode();
}
// Update line thickness based on mousewheel // Update line thickness based on mousewheel
lineThickness += GetMouseWheelMove(); lineThickness += GetMouseWheelMove();
lineThickness = Clamp(lineThickness, 1.0, 500.0f); lineThickness = Clamp(lineThickness, 1.0, 500.0f);
// Update mouse's previous position // Update mouse's previous position
mousePositionPrevious = GetMousePosition(); mousePositionPrevious = GetMousePosition();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
// Draw the render texture to the screen, flipped vertically to make it appear top-side up
DrawTextureRec(canvas.texture, (Rectangle){ 0.0f, 0.0f, (float)canvas.texture.width,(float)-canvas.texture.height }, Vector2Zero(), WHITE);
// Draw the preview circle // Draw the render texture to the screen, flipped vertically to make it appear top-side up
if (!leftButtonDown) DrawCircleLinesV(GetMousePosition(), lineThickness/2.0f, (Color){ 127, 127, 127, 127 }); DrawTextureRec(canvas.texture, (Rectangle){ 0.0f, 0.0f, (float)canvas.texture.width,(float)-canvas.texture.height }, Vector2Zero(), WHITE);
// Draw the hint text // Draw the preview circle
if (startText) DrawText("try clicking and dragging!", 275, 215, 20, LIGHTGRAY); if (!leftButtonDown) DrawCircleLinesV(GetMousePosition(), lineThickness/2.0f, (Color){ 127, 127, 127, 127 });
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization // Draw the hint text
//-------------------------------------------------------------------------------------- if (startText) DrawText("try clicking and dragging!", 275, 215, 20, LIGHTGRAY);
// Unload the canvas render texture
UnloadRenderTexture(canvas);
CloseWindow(); // Close window and OpenGL context EndDrawing();
//-------------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
}
return 0; // De-Initialization
//--------------------------------------------------------------------------------------
UnloadRenderTexture(canvas); // Unload the canvas render texture
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
} }

18
examples/shapes/shapes_math_sine_cosine.c
View File

@ -35,7 +35,7 @@ int main(void)
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT); SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - math sine cosine"); InitWindow(screenWidth, screenHeight, "raylib [shapes] example - math sine cosine");
Vector2 sinePoints[WAVE_POINTS]; Vector2 sinePoints[WAVE_POINTS];
@ -97,7 +97,7 @@ int main(void)
// Base circle and axes // Base circle and axes
DrawCircleLinesV(center, radius, GRAY); DrawCircleLinesV(center, radius, GRAY);
DrawLineEx((Vector2){ center.x, limitMin.y }, (Vector2){ center.x, limitMax.y }, 1.0f, GRAY); DrawLineEx((Vector2){ center.x, limitMin.y }, (Vector2){ center.x, limitMax.y }, 1.0f, GRAY);
DrawLineEx((Vector2){ limitMin.x, center.y }, (Vector2){ limitMax.x, center.y }, 1.f, GRAY); DrawLineEx((Vector2){ limitMin.x, center.y }, (Vector2){ limitMax.x, center.y }, 1.f, GRAY);
// Wave graph axes // Wave graph axes
@ -110,17 +110,17 @@ int main(void)
DrawText("0", start.x - 8, start.y + start.height/2 - 6, 6, GRAY); DrawText("0", start.x - 8, start.y + start.height/2 - 6, 6, GRAY);
DrawText("-1", start.x - 12, start.y + start.height - 8, 6, GRAY); DrawText("-1", start.x - 12, start.y + start.height - 8, 6, GRAY);
DrawText("0", start.x - 2, start.y + start.height + 4, 6, GRAY); DrawText("0", start.x - 2, start.y + start.height + 4, 6, GRAY);
DrawText("360", start.x + start.width - 8, start.y + start.height + 4, 6, GRAY); DrawText("360", start.x + start.width - 8, start.y + start.height + 4, 6, GRAY);
// Sine (red - vertical) // Sine (red - vertical)
DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ center.x, point.y }, 2.0f, RED); DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ center.x, point.y }, 2.0f, RED);
DrawLineDashed((Vector2){ point.x, center.y }, (Vector2){ point.x, point.y }, 10.0f, 4.0f, RED); DrawLineDashed((Vector2){ point.x, center.y }, (Vector2){ point.x, point.y }, 10.0f, 4.0f, RED);
DrawText(TextFormat("Sine %.2f", sinRad), 640, 190, 6, RED); DrawText(TextFormat("Sine %.2f", sinRad), 640, 190, 6, RED);
DrawCircleV((Vector2){ start.x + (angle/360.0f)*start.width, start.y + ((-sinRad + 1)*start.height/2.0f) }, 4.0f, RED); DrawCircleV((Vector2){ start.x + (angle/360.0f)*start.width, start.y + ((-sinRad + 1)*start.height/2.0f) }, 4.0f, RED);
DrawSplineLinear(sinePoints, WAVE_POINTS, 1.0f, RED); DrawSplineLinear(sinePoints, WAVE_POINTS, 1.0f, RED);
// Cosine (blue - horizontal) // Cosine (blue - horizontal)
DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ point.x, center.y }, 2.0f, BLUE); DrawLineEx((Vector2){ center.x, center.y }, (Vector2){ point.x, center.y }, 2.0f, BLUE);
DrawLineDashed((Vector2){ center.x , point.y }, (Vector2){ point.x, point.y }, 10.0f, 4.0f, BLUE); DrawLineDashed((Vector2){ center.x , point.y }, (Vector2){ point.x, point.y }, 10.0f, 4.0f, BLUE);
DrawText(TextFormat("Cosine %.2f", cosRad), 640, 210, 6, BLUE); DrawText(TextFormat("Cosine %.2f", cosRad), 640, 210, 6, BLUE);
DrawCircleV((Vector2){ start.x + (angle/360.0f)*start.width, start.y + ((-cosRad + 1)*start.height/2.0f) }, 4.0f, BLUE); DrawCircleV((Vector2){ start.x + (angle/360.0f)*start.width, start.y + ((-cosRad + 1)*start.height/2.0f) }, 4.0f, BLUE);
@ -135,7 +135,7 @@ int main(void)
DrawText(TextFormat("Cotangent %.2f", cotangent), 640, 250, 6, ORANGE); DrawText(TextFormat("Cotangent %.2f", cotangent), 640, 250, 6, ORANGE);
// Complementary angle (beige) // Complementary angle (beige)
DrawCircleSectorLines(center, radius*0.6f , -angle, -90.f , 36.0f, BEIGE); DrawCircleSectorLines(center, radius*0.6f , -angle, -90.f , 36.0f, BEIGE);
DrawText(TextFormat("Complementary %0.f°",complementary), 640, 150, 6, BEIGE); DrawText(TextFormat("Complementary %0.f°",complementary), 640, 150, 6, BEIGE);
// Supplementary angle (darkblue) // Supplementary angle (darkblue)
@ -147,19 +147,19 @@ int main(void)
DrawText(TextFormat("Explementary %0.f°",explementary), 640, 170, 6, PINK); DrawText(TextFormat("Explementary %0.f°",explementary), 640, 170, 6, PINK);
// Current angle - arc (lime), radius (black), endpoint (black) // Current angle - arc (lime), radius (black), endpoint (black)
DrawCircleSectorLines(center, radius*0.7f , -angle, 0.f, 36.0f, LIME); DrawCircleSectorLines(center, radius*0.7f , -angle, 0.f, 36.0f, LIME);
DrawLineEx((Vector2){ center.x , center.y }, point, 2.0f, BLACK); DrawLineEx((Vector2){ center.x , center.y }, point, 2.0f, BLACK);
DrawCircleV(point, 4.0f, BLACK); DrawCircleV(point, 4.0f, BLACK);
// Draw GUI controls // Draw GUI controls
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, ColorToInt(GRAY)); GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, ColorToInt(GRAY));
GuiToggle((Rectangle){ 640, 70, 120, 20}, TextFormat("Pause"), &pause); GuiToggle((Rectangle){ 640, 70, 120, 20}, TextFormat("Pause"), &pause);
GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, ColorToInt(LIME)); GuiSetStyle(LABEL, TEXT_COLOR_NORMAL, ColorToInt(LIME));
GuiSliderBar((Rectangle){ 640, 40, 120, 20}, "Angle", TextFormat("%.0f°", angle), &angle, 0.0f, 360.f); GuiSliderBar((Rectangle){ 640, 40, 120, 20}, "Angle", TextFormat("%.0f°", angle), &angle, 0.0f, 360.f);
// Angle values panel // Angle values panel
GuiGroupBox((Rectangle){ 620, 110, 140, 170}, "Angle Values"); GuiGroupBox((Rectangle){ 620, 110, 140, 170}, "Angle Values");
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
DrawFPS(10, 10); DrawFPS(10, 10);

20
examples/shapes/shapes_mouse_trail.c
View File

@ -35,7 +35,7 @@ int main(void)
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - mouse trail"); InitWindow(screenWidth, screenHeight, "raylib [shapes] example - mouse trail");
// Array to store the history of mouse positions (our fixed-size queue) // Array to store the history of mouse positions (our fixed-size queue)
Vector2 trailPositions[MAX_TRAIL_LENGTH] = { 0 }; Vector2 trailPositions[MAX_TRAIL_LENGTH] = { 0 };
SetTargetFPS(60); SetTargetFPS(60);
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -62,8 +62,8 @@ int main(void)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(BLACK); ClearBackground(BLACK);
// Draw the trail by looping through the history array // Draw the trail by looping through the history array
for (int i = 0; i < MAX_TRAIL_LENGTH; i++) for (int i = 0; i < MAX_TRAIL_LENGTH; i++)
{ {
@ -71,22 +71,22 @@ int main(void)
if ((trailPositions[i].x != 0.0f) || (trailPositions[i].y != 0.0f)) if ((trailPositions[i].x != 0.0f) || (trailPositions[i].y != 0.0f))
{ {
// Calculate relative trail strength (ratio is near 1.0 for new, near 0.0 for old) // Calculate relative trail strength (ratio is near 1.0 for new, near 0.0 for old)
float ratio = (float)(MAX_TRAIL_LENGTH - i) / MAX_TRAIL_LENGTH; float ratio = (float)(MAX_TRAIL_LENGTH - i) / MAX_TRAIL_LENGTH;
// Fade effect: oldest positions are more transparent // Fade effect: oldest positions are more transparent
// Fade (color, alpha) - alpha is 0.5 to 1.0 based on ratio // Fade (color, alpha) - alpha is 0.5 to 1.0 based on ratio
Color trailColor = Fade(SKYBLUE, ratio*0.5f + 0.5f); Color trailColor = Fade(SKYBLUE, ratio*0.5f + 0.5f);
// Size effect: oldest positions are smaller // Size effect: oldest positions are smaller
float trailRadius = 15.0f*ratio; float trailRadius = 15.0f*ratio;
DrawCircleV(trailPositions[i], trailRadius, trailColor); DrawCircleV(trailPositions[i], trailRadius, trailColor);
} }
} }
// Draw a distinct white circle for the current mouse position (Index 0) // Draw a distinct white circle for the current mouse position (Index 0)
DrawCircleV(mousePosition, 15.0f, WHITE); DrawCircleV(mousePosition, 15.0f, WHITE);
DrawText("Move the mouse to see the trail effect!", 10, screenHeight - 30, 20, LIGHTGRAY); DrawText("Move the mouse to see the trail effect!", 10, screenHeight - 30, 20, LIGHTGRAY);
EndDrawing(); EndDrawing();

16
examples/shapes/shapes_pie_chart.c
View File

@ -67,7 +67,7 @@ int main(void)
const Rectangle panelRect = { const Rectangle panelRect = {
panelPos.x, panelPos.y, panelPos.x, panelPos.y,
(float)panelWidth, (float)panelWidth,
(float)screenHeight - 2.0f*panelMargin (float)screenHeight - 2.0f*panelMargin
}; };
// Pie chart geometry // Pie chart geometry
@ -108,13 +108,13 @@ int main(void)
for (int i = 0; i < sliceCount; i++) for (int i = 0; i < sliceCount; i++)
{ {
float sweep = (totalValue > 0)? (values[i]/totalValue)*360.0f : 0.0f; float sweep = (totalValue > 0)? (values[i]/totalValue)*360.0f : 0.0f;
if ((angle >= currentAngle) && (angle < (currentAngle + sweep))) if ((angle >= currentAngle) && (angle < (currentAngle + sweep)))
{ {
hoveredSlice = i; hoveredSlice = i;
break; break;
} }
currentAngle += sweep; currentAngle += sweep;
} }
} }
@ -182,11 +182,11 @@ int main(void)
GuiLine((Rectangle){ panelPos.x + 10, (float)panelPos.y + 12 + 170, panelRect.width - 20, 1 }, NULL); GuiLine((Rectangle){ panelPos.x + 10, (float)panelPos.y + 12 + 170, panelRect.width - 20, 1 }, NULL);
// Scrollable area for slice editors // Scrollable area for slice editors
scrollPanelBounds = (Rectangle){ scrollPanelBounds = (Rectangle){
panelPos.x + panelMargin, panelPos.x + panelMargin,
(float)panelPos.y + 12 + 190, (float)panelPos.y + 12 + 190,
panelRect.width - panelMargin*2, panelRect.width - panelMargin*2,
panelRect.y + panelRect.height - panelPos.y + 12 + 190 - panelMargin panelRect.y + panelRect.height - panelPos.y + 12 + 190 - panelMargin
}; };
int contentHeight = sliceCount*35; int contentHeight = sliceCount*35;

12
examples/shapes/shapes_recursive_tree.c
View File

@ -45,7 +45,7 @@ int main(void)
Vector2 start = { (screenWidth/2.0f) - 125.0f, (float)screenHeight }; Vector2 start = { (screenWidth/2.0f) - 125.0f, (float)screenHeight };
float angle = 40.0f; float angle = 40.0f;
float thick = 1.0f; float thick = 1.0f;
float treeDepth = 10.0f; float treeDepth = 10.0f;
float branchDecay = 0.66f; float branchDecay = 0.66f;
float length = 120.0f; float length = 120.0f;
@ -67,21 +67,21 @@ int main(void)
Vector2 initialEnd = { start.x + length*sinf(0.0f), start.y - length*cosf(0.0f) }; Vector2 initialEnd = { start.x + length*sinf(0.0f), start.y - length*cosf(0.0f) };
branches[count++] = (Branch){start, initialEnd, 0.0f, length}; branches[count++] = (Branch){start, initialEnd, 0.0f, length};
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
Branch branch = branches[i]; Branch branch = branches[i];
if (branch.length < 2) continue; if (branch.length < 2) continue;
float nextLength = branch.length*branchDecay; float nextLength = branch.length*branchDecay;
if (count < maxBranches && nextLength >= 2) if (count < maxBranches && nextLength >= 2)
{ {
Vector2 branchStart = branch.end; Vector2 branchStart = branch.end;
float angle1 = branch.angle + theta; float angle1 = branch.angle + theta;
Vector2 branchEnd1 = { branchStart.x + nextLength*sinf(angle1), branchStart.y - nextLength*cosf(angle1) }; Vector2 branchEnd1 = { branchStart.x + nextLength*sinf(angle1), branchStart.y - nextLength*cosf(angle1) };
branches[count++] = (Branch){branchStart, branchEnd1, angle1, nextLength}; branches[count++] = (Branch){branchStart, branchEnd1, angle1, nextLength};
float angle2 = branch.angle - theta; float angle2 = branch.angle - theta;
Vector2 branchEnd2 = { branchStart.x + nextLength*sinf(angle2), branchStart.y - nextLength*cosf(angle2) }; Vector2 branchEnd2 = { branchStart.x + nextLength*sinf(angle2), branchStart.y - nextLength*cosf(angle2) };
branches[count++] = (Branch){branchStart, branchEnd2, angle2, nextLength}; branches[count++] = (Branch){branchStart, branchEnd2, angle2, nextLength};
@ -94,10 +94,10 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
for (int i = 0; i < count; i++) for (int i = 0; i < count; i++)
{ {
Branch branch = branches[i]; Branch branch = branches[i];
if (branch.length >= 2) if (branch.length >= 2)
{ {
if (bezier) DrawLineBezier(branch.start, branch.end, thick, RED); if (bezier) DrawLineBezier(branch.start, branch.end, thick, RED);
else DrawLineEx(branch.start, branch.end, thick, RED); else DrawLineEx(branch.start, branch.end, thick, RED);

12
examples/shapes/shapes_rlgl_triangle.c
View File

@ -50,7 +50,7 @@ int main(void)
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
if (IsKeyPressed(KEY_SPACE)) linesMode = !linesMode; if (IsKeyPressed(KEY_SPACE)) linesMode = !linesMode;
// Check selected vertex // Check selected vertex
for (unsigned int i = 0; i < 3; i++) for (unsigned int i = 0; i < 3; i++)
{ {
@ -72,7 +72,7 @@ int main(void)
position->x += mouseDelta.x; position->x += mouseDelta.x;
position->y += mouseDelta.y; position->y += mouseDelta.y;
} }
// Reset index on release // Reset index on release
if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) triangleIndex = -1; if (IsMouseButtonReleased(MOUSE_BUTTON_LEFT)) triangleIndex = -1;
@ -139,15 +139,15 @@ int main(void)
// Render the vertex handles, reacting to mouse movement/input // Render the vertex handles, reacting to mouse movement/input
for (unsigned int i = 0; i < 3; i++) for (unsigned int i = 0; i < 3; i++)
{ {
// Draw handle fill focused by mouse // Draw handle fill focused by mouse
if (CheckCollisionPointCircle(GetMousePosition(), trianglePositions[i], handleRadius)) if (CheckCollisionPointCircle(GetMousePosition(), trianglePositions[i], handleRadius))
DrawCircleV(trianglePositions[i], handleRadius, ColorAlpha(DARKGRAY, 0.5f)); DrawCircleV(trianglePositions[i], handleRadius, ColorAlpha(DARKGRAY, 0.5f));
// Draw handle fill selected // Draw handle fill selected
if (i == triangleIndex) DrawCircleV(trianglePositions[i], handleRadius, DARKGRAY); if (i == triangleIndex) DrawCircleV(trianglePositions[i], handleRadius, DARKGRAY);
// Draw handle outline // Draw handle outline
DrawCircleLinesV(trianglePositions[i], handleRadius, BLACK); DrawCircleLinesV(trianglePositions[i], handleRadius, BLACK);
} }
// Draw controls // Draw controls

54
examples/shapes/shapes_simple_particles.c
View File

@ -36,7 +36,7 @@ static const char particleTypeNames[3][10] = { "WATER", "SMOKE", "FIRE" };
typedef struct Particle { typedef struct Particle {
ParticleType type; // Particle type (WATER, SMOKE, FIRE) ParticleType type; // Particle type (WATER, SMOKE, FIRE)
Vector2 position; // Particle position on screen Vector2 position; // Particle position on screen
Vector2 velocity; // Particle current speed and direction Vector2 velocity; // Particle current speed and direction
float radius; // Particle radius float radius; // Particle radius
Color color; // Particle color Color color; // Particle color
@ -45,9 +45,9 @@ typedef struct Particle {
} Particle; } Particle;
typedef struct CircularBuffer { typedef struct CircularBuffer {
int head; // Index for the next write int head; // Index for the next write
int tail; // Index for the next read int tail; // Index for the next read
Particle *buffer; // Particle buffer array Particle *buffer; // Particle buffer array
} CircularBuffer; } CircularBuffer;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
@ -73,12 +73,12 @@ int main(void)
// Definition of particles // Definition of particles
Particle *particles = (Particle*)RL_CALLOC(MAX_PARTICLES, sizeof(Particle)); // Particle array Particle *particles = (Particle*)RL_CALLOC(MAX_PARTICLES, sizeof(Particle)); // Particle array
CircularBuffer circularBuffer = { 0, 0, particles }; CircularBuffer circularBuffer = { 0, 0, particles };
// Particle emitter parameters // Particle emitter parameters
int emissionRate = -2; // Negative: on average every -X frames. Positive: particles per frame int emissionRate = -2; // Negative: on average every -X frames. Positive: particles per frame
ParticleType currentType = WATER; ParticleType currentType = WATER;
Vector2 emitterPosition = { screenWidth/2.0f, screenHeight/2.0f }; Vector2 emitterPosition = { screenWidth/2.0f, screenHeight/2.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
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -88,7 +88,7 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Emit new particles: when emissionRate is 1, emit every frame // Emit new particles: when emissionRate is 1, emit every frame
if (emissionRate < 0) if (emissionRate < 0)
{ {
if (rand()%(-emissionRate) == 0) EmitParticle(&circularBuffer, emitterPosition, currentType); if (rand()%(-emissionRate) == 0) EmitParticle(&circularBuffer, emitterPosition, currentType);
@ -96,9 +96,9 @@ int main(void)
else else
{ {
for (int i = 0; i <= emissionRate; ++i) EmitParticle(&circularBuffer, emitterPosition, currentType); for (int i = 0; i <= emissionRate; ++i) EmitParticle(&circularBuffer, emitterPosition, currentType);
} }
// Update the parameters of each particle // Update the parameters of each particle
UpdateParticles(&circularBuffer, screenWidth, screenHeight); UpdateParticles(&circularBuffer, screenWidth, screenHeight);
// Remove dead particles from the circular buffer // Remove dead particles from the circular buffer
@ -112,7 +112,7 @@ int main(void)
if (IsKeyPressed(KEY_RIGHT)) (currentType == FIRE)? (currentType = WATER) : currentType++; if (IsKeyPressed(KEY_RIGHT)) (currentType == FIRE)? (currentType = WATER) : currentType++;
if (IsKeyPressed(KEY_LEFT)) (currentType == WATER)? (currentType = FIRE) : currentType--; if (IsKeyPressed(KEY_LEFT)) (currentType == WATER)? (currentType = FIRE) : currentType--;
if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) emitterPosition = GetMousePosition(); if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) emitterPosition = GetMousePosition();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -121,7 +121,7 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// Call the function with a loop to draw all particles // Call the function with a loop to draw all particles
DrawParticles(&circularBuffer); DrawParticles(&circularBuffer);
// Draw UI and Instructions // Draw UI and Instructions
@ -133,7 +133,7 @@ int main(void)
DrawText("LEFT/RIGHT: Change Particle Type (Water, Smoke, Fire)", 15, 55, 10, BLACK); DrawText("LEFT/RIGHT: Change Particle Type (Water, Smoke, Fire)", 15, 55, 10, BLACK);
if (emissionRate < 0) DrawText(TextFormat("Particles every %d frames | Type: %s", -emissionRate, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY); if (emissionRate < 0) DrawText(TextFormat("Particles every %d frames | Type: %s", -emissionRate, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY);
else DrawText(TextFormat("%d Particles per frame | Type: %s", emissionRate + 1, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY); else DrawText(TextFormat("%d Particles per frame | Type: %s", emissionRate + 1, particleTypeNames[currentType]), 15, 95, 10, DARKGRAY);
DrawFPS(screenWidth - 80, 10); DrawFPS(screenWidth - 80, 10);
@ -200,12 +200,12 @@ static Particle *AddToCircularBuffer(CircularBuffer *circularBuffer)
// Check if buffer full // Check if buffer full
if (((circularBuffer->head + 1)%MAX_PARTICLES) != circularBuffer->tail) if (((circularBuffer->head + 1)%MAX_PARTICLES) != circularBuffer->tail)
{ {
// Add new particle to the head position and advance head // Add new particle to the head position and advance head
particle = &circularBuffer->buffer[circularBuffer->head]; particle = &circularBuffer->buffer[circularBuffer->head];
circularBuffer->head = (circularBuffer->head + 1)%MAX_PARTICLES; circularBuffer->head = (circularBuffer->head + 1)%MAX_PARTICLES;
} }
return particle; return particle;
} }
static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int screenHeight) static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int screenHeight)
@ -213,7 +213,7 @@ static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int
for (int i = circularBuffer->tail; i != circularBuffer->head; i = (i + 1)%MAX_PARTICLES) for (int i = circularBuffer->tail; i != circularBuffer->head; i = (i + 1)%MAX_PARTICLES)
{ {
// Update particle life and positions // Update particle life and positions
circularBuffer->buffer[i].lifeTime += 1.0f/60.0f; // 60 FPS -> 1/60 seconds per frame circularBuffer->buffer[i].lifeTime += 1.0f/60.0f; // 60 FPS -> 1/60 seconds per frame
switch (circularBuffer->buffer[i].type) switch (circularBuffer->buffer[i].type)
{ {
@ -226,32 +226,32 @@ static void UpdateParticles(CircularBuffer *circularBuffer, int screenWidth, int
case SMOKE: case SMOKE:
{ {
circularBuffer->buffer[i].position.x += circularBuffer->buffer[i].velocity.x; circularBuffer->buffer[i].position.x += circularBuffer->buffer[i].velocity.x;
circularBuffer->buffer[i].velocity.y -= 0.05f; // Upwards circularBuffer->buffer[i].velocity.y -= 0.05f; // Upwards
circularBuffer->buffer[i].position.y += circularBuffer->buffer[i].velocity.y; circularBuffer->buffer[i].position.y += circularBuffer->buffer[i].velocity.y;
circularBuffer->buffer[i].radius += 0.5f; // Increment radius: smoke expands circularBuffer->buffer[i].radius += 0.5f; // Increment radius: smoke expands
circularBuffer->buffer[i].color.a -= 4; // Decrement alpha: smoke fades circularBuffer->buffer[i].color.a -= 4; // Decrement alpha: smoke fades
// If alpha transparent, particle dies // If alpha transparent, particle dies
if (circularBuffer->buffer[i].color.a < 4) circularBuffer->buffer[i].alive = false; if (circularBuffer->buffer[i].color.a < 4) circularBuffer->buffer[i].alive = false;
} break; } break;
case FIRE: case FIRE:
{ {
// Add a little horizontal oscillation to fire particles // Add a little horizontal oscillation to fire particles
circularBuffer->buffer[i].position.x += circularBuffer->buffer[i].velocity.x + cosf(circularBuffer->buffer[i].lifeTime*215.0f); circularBuffer->buffer[i].position.x += circularBuffer->buffer[i].velocity.x + cosf(circularBuffer->buffer[i].lifeTime*215.0f);
circularBuffer->buffer[i].velocity.y -= 0.05f; // Upwards circularBuffer->buffer[i].velocity.y -= 0.05f; // Upwards
circularBuffer->buffer[i].position.y += circularBuffer->buffer[i].velocity.y; circularBuffer->buffer[i].position.y += circularBuffer->buffer[i].velocity.y;
circularBuffer->buffer[i].radius -= 0.15f; // Decrement radius: fire shrinks circularBuffer->buffer[i].radius -= 0.15f; // Decrement radius: fire shrinks
circularBuffer->buffer[i].color.g -= 3; // Decrement green: fire turns reddish starting from yellow circularBuffer->buffer[i].color.g -= 3; // Decrement green: fire turns reddish starting from yellow
// If radius too small, particle dies // If radius too small, particle dies
if (circularBuffer->buffer[i].radius <= 0.02f) circularBuffer->buffer[i].alive = false; if (circularBuffer->buffer[i].radius <= 0.02f) circularBuffer->buffer[i].alive = false;
} break; } break;
default: break; default: break;
} }
// Disable particle when out of screen // Disable particle when out of screen
Vector2 center = circularBuffer->buffer[i].position; Vector2 center = circularBuffer->buffer[i].position;
float radius = circularBuffer->buffer[i].radius; float radius = circularBuffer->buffer[i].radius;
if ((center.x < -radius) || (center.x > (screenWidth + radius)) || if ((center.x < -radius) || (center.x > (screenWidth + radius)) ||
(center.y < -radius) || (center.y > (screenHeight + radius))) (center.y < -radius) || (center.y > (screenHeight + radius)))
@ -267,7 +267,7 @@ static void UpdateCircularBuffer(CircularBuffer *circularBuffer)
while ((circularBuffer->tail != circularBuffer->head) && !circularBuffer->buffer[circularBuffer->tail].alive) while ((circularBuffer->tail != circularBuffer->head) && !circularBuffer->buffer[circularBuffer->tail].alive)
{ {
circularBuffer->tail = (circularBuffer->tail + 1)%MAX_PARTICLES; circularBuffer->tail = (circularBuffer->tail + 1)%MAX_PARTICLES;
} }
} }
static void DrawParticles(CircularBuffer *circularBuffer) static void DrawParticles(CircularBuffer *circularBuffer)

6
examples/shapes/shapes_triangle_strip.c
View File

@ -39,7 +39,7 @@ int main(void)
float insideRadius = 100.0f; float insideRadius = 100.0f;
float outsideRadius = 150.0f; float outsideRadius = 150.0f;
bool outline = true; bool outline = true;
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -79,14 +79,14 @@ int main(void)
float angle1 = i*angleStep; float angle1 = i*angleStep;
DrawTriangle(c, b, a, ColorFromHSV(angle1*RAD2DEG, 1.0f, 1.0f)); DrawTriangle(c, b, a, ColorFromHSV(angle1*RAD2DEG, 1.0f, 1.0f));
DrawTriangle(d, b, c, ColorFromHSV((angle1 + angleStep/2)*RAD2DEG, 1.0f, 1.0f)); DrawTriangle(d, b, c, ColorFromHSV((angle1 + angleStep/2)*RAD2DEG, 1.0f, 1.0f));
if (outline) if (outline)
{ {
DrawTriangleLines(a, b, c, BLACK); DrawTriangleLines(a, b, c, BLACK);
DrawTriangleLines(c, b, d, BLACK); DrawTriangleLines(c, b, d, BLACK);
} }
} }
DrawLine(580, 0, 580, GetScreenHeight(), (Color){ 218, 218, 218, 255 }); DrawLine(580, 0, 580, GetScreenHeight(), (Color){ 218, 218, 218, 255 });
DrawRectangle(580, 0, GetScreenWidth(), GetScreenHeight(), (Color){ 232, 232, 232, 255 }); DrawRectangle(580, 0, GetScreenWidth(), GetScreenHeight(), (Color){ 232, 232, 232, 255 });

2
examples/shapes/shapes_vector_angle.c
View File

@ -25,7 +25,7 @@ int main(void)
// Initialization // Initialization
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
const int screenWidth = 800; const int screenWidth = 800;
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [shapes] example - vector angle"); InitWindow(screenWidth, screenHeight, "raylib [shapes] example - vector angle");

34
examples/text/text_inline_styling.c
View File

@ -36,11 +36,11 @@ int main(void)
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [text] example - inline styling"); InitWindow(screenWidth, screenHeight, "raylib [text] example - inline styling");
Vector2 textSize = { 0 }; // Measure text box for provided font and text Vector2 textSize = { 0 }; // Measure text box for provided font and text
Color colRandom = RED; // Random color used on text Color colRandom = RED; // Random color used on text
int frameCounter = 0; // Used to generate a new random color every certain frames int frameCounter = 0; // Used to generate a new random color every certain frames
SetTargetFPS(60); // Set our game to run at 60 frames-per-second SetTargetFPS(60); // Set our game to run at 60 frames-per-second
//-------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------
@ -50,7 +50,7 @@ int main(void)
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
frameCounter++; frameCounter++;
if ((frameCounter%20) == 0) if ((frameCounter%20) == 0)
{ {
colRandom.r = (unsigned char)GetRandomValue(0, 255); colRandom.r = (unsigned char)GetRandomValue(0, 255);
@ -67,12 +67,12 @@ int main(void)
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
// Text inline styling strategy used: [ ] delimiters for format // Text inline styling strategy used: [ ] delimiters for format
// - Define foreground color: [cRRGGBBAA] // - Define foreground color: [cRRGGBBAA]
// - Define background color: [bRRGGBBAA] // - Define background color: [bRRGGBBAA]
// - Reset formating: [r] // - Reset formating: [r]
// Example: [bAA00AAFF][cFF0000FF]red text on gray background[r] normal text // Example: [bAA00AAFF][cFF0000FF]red text on gray background[r] normal text
DrawTextStyled(GetFontDefault(), "This changes the [cFF0000FF]foreground color[r] of provided text!!!", DrawTextStyled(GetFontDefault(), "This changes the [cFF0000FF]foreground color[r] of provided text!!!",
(Vector2){ 100, 80 }, 20.0f, 2.0f, BLACK); (Vector2){ 100, 80 }, 20.0f, 2.0f, BLACK);
DrawTextStyled(GetFontDefault(), "This changes the [bFF00FFFF]background color[r] of provided text!!!", DrawTextStyled(GetFontDefault(), "This changes the [bFF00FFFF]background color[r] of provided text!!!",
@ -80,11 +80,11 @@ int main(void)
DrawTextStyled(GetFontDefault(), "This changes the [c00ff00ff][bff0000ff]foreground and background colors[r]!!!", DrawTextStyled(GetFontDefault(), "This changes the [c00ff00ff][bff0000ff]foreground and background colors[r]!!!",
(Vector2){ 100, 160 }, 20.0f, 2.0f, BLACK); (Vector2){ 100, 160 }, 20.0f, 2.0f, BLACK);
// Get pointer to formated text // Get pointer to formated text
const char *text = TextFormat("Let's be [c%02x%02x%02xFF]CREATIVE[r] !!!", colRandom.r, colRandom.g, colRandom.b); const char *text = TextFormat("Let's be [c%02x%02x%02xFF]CREATIVE[r] !!!", colRandom.r, colRandom.g, colRandom.b);
DrawTextStyled(GetFontDefault(), text, (Vector2){ 100, 220 }, 40.0f, 2.0f, BLACK); DrawTextStyled(GetFontDefault(), text, (Vector2){ 100, 220 }, 40.0f, 2.0f, BLACK);
textSize = MeasureTextStyled(GetFontDefault(), text, 40.0f, 2.0f); textSize = MeasureTextStyled(GetFontDefault(), text, 40.0f, 2.0f);
DrawRectangleLines(100, 220, (int)textSize.x, (int)textSize.y, GREEN); DrawRectangleLines(100, 220, (int)textSize.x, (int)textSize.y, GREEN);
@ -108,13 +108,13 @@ int main(void)
static void DrawTextStyled(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color color) static void DrawTextStyled(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color color)
{ {
// Text inline styling strategy used: [ ] delimiters for format // Text inline styling strategy used: [ ] delimiters for format
// - Define foreground color: [cRRGGBBAA] // - Define foreground color: [cRRGGBBAA]
// - Define background color: [bRRGGBBAA] // - Define background color: [bRRGGBBAA]
// - Reset formating: [r] // - Reset formating: [r]
// Example: [bAA00AAFF][cFF0000FF]red text on gray background[r] normal text // Example: [bAA00AAFF][cFF0000FF]red text on gray background[r] normal text
if (font.texture.id == 0) font = GetFontDefault(); if (font.texture.id == 0) font = GetFontDefault();
int textLen = TextLength(text); int textLen = TextLength(text);
Color colFront = color; Color colFront = color;
@ -144,14 +144,14 @@ static void DrawTextStyled(Font font, const char *text, Vector2 position, float
{ {
colFront = color; colFront = color;
colBack = BLANK; colBack = BLANK;
i += 3; // Skip "[r]" i += 3; // Skip "[r]"
continue; // Do not draw characters continue; // Do not draw characters
} }
else if (((i + 1) < textLen) && ((text[i + 1] == 'c') || (text[i + 1] == 'b'))) else if (((i + 1) < textLen) && ((text[i + 1] == 'c') || (text[i + 1] == 'b')))
{ {
i += 2; // Skip "[c" or "[b" to start parsing color i += 2; // Skip "[c" or "[b" to start parsing color
// Parse following color // Parse following color
char colHexText[9] = { 0 }; char colHexText[9] = { 0 };
const char *textPtr = &text[i]; // Color should start here, let's see... const char *textPtr = &text[i]; // Color should start here, let's see...
@ -168,12 +168,12 @@ static void DrawTextStyled(Font font, const char *text, Vector2 position, float
} }
else break; // Only affects while loop else break; // Only affects while loop
} }
// Convert hex color text into actual Color // Convert hex color text into actual Color
unsigned int colHexValue = strtoul(colHexText, NULL, 16); unsigned int colHexValue = strtoul(colHexText, NULL, 16);
if (text[i - 1] == 'c') colFront = GetColor(colHexValue); if (text[i - 1] == 'c') colFront = GetColor(colHexValue);
else if (text[i - 1] == 'b') colBack = GetColor(colHexValue); else if (text[i - 1] == 'b') colBack = GetColor(colHexValue);
i += (colHexCount + 1); // Skip color value retrieved and ']' i += (colHexCount + 1); // Skip color value retrieved and ']'
continue; // Do not draw characters continue; // Do not draw characters
} }
@ -249,7 +249,7 @@ static Vector2 MeasureTextStyled(Font font, const char *text, float fontSize, fl
} }
else break; // Only affects while loop else break; // Only affects while loop
} }
i += (colHexCount + 1); // Skip color value retrieved and ']' i += (colHexCount + 1); // Skip color value retrieved and ']'
continue; // Do not measure characters continue; // Do not measure characters
} }
@ -260,7 +260,7 @@ static Vector2 MeasureTextStyled(Font font, const char *text, float fontSize, fl
if (font.glyphs[index].advanceX > 0) textWidth += font.glyphs[index].advanceX; if (font.glyphs[index].advanceX > 0) textWidth += font.glyphs[index].advanceX;
else textWidth += (font.recs[index].width + font.glyphs[index].offsetX); else textWidth += (font.recs[index].width + font.glyphs[index].offsetX);
validCodepointCounter++; validCodepointCounter++;
i += codepointByteCount; i += codepointByteCount;
} }

14
examples/text/text_unicode_ranges.c
View File

@ -58,7 +58,7 @@ int main(void)
// Load font with default Unicode range: Basic ASCII [32-127] // Load font with default Unicode range: Basic ASCII [32-127]
font = LoadFont("resources/NotoSansTC-Regular.ttf"); font = LoadFont("resources/NotoSansTC-Regular.ttf");
// Add required ranges to loaded font // Add required ranges to loaded font
switch (unicodeRange) switch (unicodeRange)
{ {
@ -128,11 +128,11 @@ int main(void)
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
BeginDrawing(); BeginDrawing();
ClearBackground(RAYWHITE); ClearBackground(RAYWHITE);
DrawText("ADD CODEPOINTS: [1][2][3][4]", 20, 20, 20, MAROON); DrawText("ADD CODEPOINTS: [1][2][3][4]", 20, 20, 20, MAROON);
// Render test strings in different languages // Render test strings in different languages
DrawTextEx(font, "> English: Hello World!", (Vector2){ 50, 70 }, 32, 1, DARKGRAY); // English DrawTextEx(font, "> English: Hello World!", (Vector2){ 50, 70 }, 32, 1, DARKGRAY); // English
DrawTextEx(font, "> Español: Hola mundo!", (Vector2){ 50, 120 }, 32, 1, DARKGRAY); // Spanish DrawTextEx(font, "> Español: Hola mundo!", (Vector2){ 50, 120 }, 32, 1, DARKGRAY); // Spanish
@ -141,7 +141,7 @@ int main(void)
DrawTextEx(font, "> 中文: 你好世界!", (Vector2){ 50, 270 }, 32, 1, DARKGRAY); // Chinese DrawTextEx(font, "> 中文: 你好世界!", (Vector2){ 50, 270 }, 32, 1, DARKGRAY); // Chinese
DrawTextEx(font, "> 日本語: こんにちは世界!", (Vector2){ 50, 320 }, 32, 1, DARKGRAY); // Japanese DrawTextEx(font, "> 日本語: こんにちは世界!", (Vector2){ 50, 320 }, 32, 1, DARKGRAY); // Japanese
//DrawTextEx(font, "देवनागरी: होला मुंडो!", (Vector2){ 50, 350 }, 32, 1, DARKGRAY); // Devanagari (glyphs not available in font) //DrawTextEx(font, "देवनागरी: होला मुंडो!", (Vector2){ 50, 350 }, 32, 1, DARKGRAY); // Devanagari (glyphs not available in font)
// Draw font texture scaled to screen // Draw font texture scaled to screen
float atlasScale = 380.0f/font.texture.width; float atlasScale = 380.0f/font.texture.width;
DrawRectangleRec((Rectangle) { 400.0f, 16.0f, font.texture.width* atlasScale, font.texture.height* atlasScale }, BLACK); DrawRectangleRec((Rectangle) { 400.0f, 16.0f, font.texture.width* atlasScale, font.texture.height* atlasScale }, BLACK);
@ -161,7 +161,7 @@ int main(void)
DrawRectangle(0, 125, screenWidth, 200, GRAY); DrawRectangle(0, 125, screenWidth, 200, GRAY);
DrawText("GENERATING FONT ATLAS...", 120, 210, 40, BLACK); DrawText("GENERATING FONT ATLAS...", 120, 210, 40, BLACK);
} }
EndDrawing(); EndDrawing();
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
} }
@ -184,10 +184,10 @@ static void AddCodepointRange(Font *font, const char *fontPath, int start, int s
{ {
int rangeSize = stop - start + 1; int rangeSize = stop - start + 1;
int currentRangeSize = font->glyphCount; int currentRangeSize = font->glyphCount;
// TODO: Load glyphs from provided vector font (if available), // TODO: Load glyphs from provided vector font (if available),
// add them to existing font, regenerating font image and texture // add them to existing font, regenerating font image and texture
int updatedCodepointCount = currentRangeSize + rangeSize; int updatedCodepointCount = currentRangeSize + rangeSize;
int *updatedCodepoints = (int *)RL_CALLOC(updatedCodepointCount, sizeof(int)); int *updatedCodepoints = (int *)RL_CALLOC(updatedCodepointCount, sizeof(int));

22
examples/text/text_words_alignment.c
View File

@ -39,25 +39,25 @@ int main(void)
const int screenHeight = 450; const int screenHeight = 450;
InitWindow(screenWidth, screenHeight, "raylib [text] example - words alignment"); InitWindow(screenWidth, screenHeight, "raylib [text] example - words alignment");
// Define the rectangle we will draw the text in // Define the rectangle we will draw the text in
Rectangle textContainerRect = (Rectangle){ screenWidth/2-screenWidth/4, screenHeight/2-screenHeight/3, screenWidth/2, screenHeight*2/3 }; Rectangle textContainerRect = (Rectangle){ screenWidth/2-screenWidth/4, screenHeight/2-screenHeight/3, screenWidth/2, screenHeight*2/3 };
// Some text to display the current alignment // Some text to display the current alignment
const char *textAlignNameH[] = { "Left", "Centre", "Right" }; const char *textAlignNameH[] = { "Left", "Centre", "Right" };
const char *textAlignNameV[] = { "Top", "Middle", "Bottom" }; const char *textAlignNameV[] = { "Top", "Middle", "Bottom" };
// Define the text we're going to draw in the rectangle // Define the text we're going to draw in the rectangle
int wordIndex = 0; int wordIndex = 0;
int wordCount = 0; int wordCount = 0;
char **words = TextSplit("raylib is a simple and easy-to-use library to enjoy videogames programming", ' ', &wordCount); char **words = TextSplit("raylib is a simple and easy-to-use library to enjoy videogames programming", ' ', &wordCount);
// Initialize the font size we're going to use // Initialize the font size we're going to use
int fontSize = 40; int fontSize = 40;
// And of course the font... // And of course the font...
Font font = GetFontDefault(); Font font = GetFontDefault();
// Intialize the alignment variables // Intialize the alignment variables
TextAlignment hAlign = TEXT_ALIGN_CENTRE; TextAlignment hAlign = TEXT_ALIGN_CENTRE;
TextAlignment vAlign = TEXT_ALIGN_MIDDLE; TextAlignment vAlign = TEXT_ALIGN_MIDDLE;
@ -70,7 +70,7 @@ int main(void)
{ {
// Update // Update
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
if (IsKeyPressed(KEY_LEFT)) { if (IsKeyPressed(KEY_LEFT)) {
hAlign = hAlign - 1; hAlign = hAlign - 1;
if (hAlign < 0) hAlign = 0; if (hAlign < 0) hAlign = 0;
@ -87,10 +87,10 @@ int main(void)
vAlign = vAlign + 1; vAlign = vAlign + 1;
if (vAlign > 2) vAlign = 2; if (vAlign > 2) vAlign = 2;
} }
// One word per second // One word per second
wordIndex = (int)GetTime() % wordCount; wordIndex = (int)GetTime() % wordCount;
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Draw // Draw
@ -103,16 +103,16 @@ int main(void)
DrawText(TextFormat("Alignment: Horizontal = %s, Vertical = %s", textAlignNameH[hAlign], textAlignNameV[vAlign]), 20, 40, 20, LIGHTGRAY); DrawText(TextFormat("Alignment: Horizontal = %s, Vertical = %s", textAlignNameH[hAlign], textAlignNameV[vAlign]), 20, 40, 20, LIGHTGRAY);
DrawRectangleRec(textContainerRect, BLUE); DrawRectangleRec(textContainerRect, BLUE);
// Get the size of the text to draw // Get the size of the text to draw
Vector2 textSize = MeasureTextEx(font, words[wordIndex], fontSize, fontSize*.1f); Vector2 textSize = MeasureTextEx(font, words[wordIndex], fontSize, fontSize*.1f);
// Calculate the top-left text position based on the rectangle and alignment // Calculate the top-left text position based on the rectangle and alignment
Vector2 textPos = (Vector2) { Vector2 textPos = (Vector2) {
textContainerRect.x + Lerp(0.0f, textContainerRect.width - textSize.x, ((float)hAlign) * 0.5f), textContainerRect.x + Lerp(0.0f, textContainerRect.width - textSize.x, ((float)hAlign) * 0.5f),
textContainerRect.y + Lerp(0.0f, textContainerRect.height - textSize.y, ((float)vAlign) * 0.5f) textContainerRect.y + Lerp(0.0f, textContainerRect.height - textSize.y, ((float)vAlign) * 0.5f)
}; };
// Draw the text // Draw the text
DrawTextEx(font, words[wordIndex], textPos, fontSize, fontSize*.1f, RAYWHITE); DrawTextEx(font, words[wordIndex], textPos, fontSize, fontSize*.1f, RAYWHITE);

8
examples/textures/textures_screen_buffer.c
View File

@ -45,7 +45,7 @@ int main(void)
Color palette[MAX_COLORS] = {0}; Color palette[MAX_COLORS] = {0};
unsigned char indexBuffer[INDEX_BUFFER_SIZE] = {0}; unsigned char indexBuffer[INDEX_BUFFER_SIZE] = {0};
unsigned char flameRootBuffer[FLAME_WIDTH] = {0}; unsigned char flameRootBuffer[FLAME_WIDTH] = {0};
Image screenImage = GenImageColor(imageWidth, imageHeight, BLACK); Image screenImage = GenImageColor(imageWidth, imageHeight, BLACK);
Texture screenTexture = LoadTextureFromImage(screenImage); Texture screenTexture = LoadTextureFromImage(screenImage);
GeneretePalette(palette); GeneretePalette(palette);
@ -74,7 +74,7 @@ int main(void)
int i = x + (imageHeight - 1) * imageWidth; int i = x + (imageHeight - 1) * imageWidth;
indexBuffer[i] = flameRootBuffer[x]; indexBuffer[i] = flameRootBuffer[x];
} }
// Clear top row, because it can't move any higher // Clear top row, because it can't move any higher
for (int x = 0; x < imageWidth; ++x) for (int x = 0; x < imageWidth; ++x)
{ {
@ -90,7 +90,7 @@ int main(void)
unsigned i = x + y * imageWidth; unsigned i = x + y * imageWidth;
unsigned char colorIndex = indexBuffer[i]; unsigned char colorIndex = indexBuffer[i];
if (colorIndex == 0) continue; if (colorIndex == 0) continue;
// Move pixel a row above // Move pixel a row above
indexBuffer[i] = 0; indexBuffer[i] = 0;
int moveX = GetRandomValue(0, 2) - 1; int moveX = GetRandomValue(0, 2) - 1;
@ -115,7 +115,7 @@ int main(void)
ImageDrawPixel(&screenImage, x, y, col); ImageDrawPixel(&screenImage, x, y, col);
} }
} }
UpdateTexture(screenTexture, screenImage.data); UpdateTexture(screenTexture, screenImage.data);
// Draw // Draw
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------