Example resize fixes using IsWindowResized()

examples/models/models_animation.c

@@ -30,8 +30,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - model animation");
 
@@ -72,6 +72,11 @@ int main(void)
             UpdateModelAnimation(model, anims[0], animFrameCounter);
             if (animFrameCounter >= anims[0].frameCount) animFrameCounter = 0;
         }
+	if (IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         //----------------------------------------------------------------------------------
 
         // Draw

examples/models/models_box_collisions.c

@@ -22,8 +22,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - box collisions");
 
@@ -50,7 +50,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
-
+	if (IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         // Move player
         if (IsKeyDown(KEY_RIGHT)) playerPosition.x += 0.2f;
         else if (IsKeyDown(KEY_LEFT)) playerPosition.x -= 0.2f;
@@ -111,7 +115,7 @@ int main(void)
 
             EndMode3D();
 
-            DrawText("Move player with arrow keys to collide", 220, 40, 20, GRAY);
+            DrawText("Move player with arrow keys to collide", screenWidth/2 - 220, 40, 20, GRAY);
 
             DrawFPS(10, 10);
 

examples/models/models_heightmap.c

@@ -22,8 +22,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - heightmap loading and drawing");
 
@@ -54,6 +54,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, CAMERA_ORBITAL);
         //----------------------------------------------------------------------------------
 

examples/models/models_loading.c

@@ -35,8 +35,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - models loading");
 
@@ -69,6 +69,11 @@ int main(void)
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
+    	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera, CAMERA_FIRST_PERSON);
@@ -132,8 +137,8 @@ int main(void)
 
             EndMode3D();
 
-            DrawText("Drag & drop model to load mesh/texture.", 10, GetScreenHeight() - 20, 10, DARKGRAY);
+            DrawText("Drag & drop model to load mesh/texture.", 10, screenHeight - 20, 10, DARKGRAY);
-            if (selected) DrawText("MODEL SELECTED", GetScreenWidth() - 110, 10, 10, GREEN);
+            if (selected) DrawText("MODEL SELECTED", screenWidth - 110, 10, 10, GREEN);
 
             DrawText("(c) Castle 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
 

examples/models/models_loading_vox.c

@@ -37,8 +37,8 @@ int main(void)
 {
 	// Initialization
 	//--------------------------------------------------------------------------------------
-	const int screenWidth = 800;
+	int screenWidth = 800;
-	const int screenHeight = 450;
+	int screenHeight = 450;
 
 	const char* voxFileNames[] = {
 		"resources/models/vox/chr_knight.vox",
@@ -126,6 +126,11 @@ int main(void)
 	{
 		// Update
 		//----------------------------------------------------------------------------------
+		if (IsWindowResized())
+		{
+			screenWidth  = GetScreenWidth();
+			screenHeight = GetScreenHeight();
+		}
 		if (IsMouseButtonDown(MOUSE_BUTTON_MIDDLE))
 		{
 			const Vector2 mouseDelta = GetMouseDelta();
@@ -182,11 +187,11 @@ int main(void)
 		EndMode3D();
 
 		// Display info
-		DrawRectangle(10, 400, 340, 60, Fade(SKYBLUE, 0.5f));
+		DrawRectangle(10, screenHeight - 50, 340, 60, Fade(SKYBLUE, 0.5f));
-		DrawRectangleLines(10, 400, 340, 60, Fade(DARKBLUE, 0.5f));
+		DrawRectangleLines(10, screenHeight - 50, 340, 60, Fade(DARKBLUE, 0.5f));
-		DrawText("MOUSE LEFT BUTTON to CYCLE VOX MODELS", 40, 410, 10, BLUE);
+		DrawText("MOUSE LEFT BUTTON to CYCLE VOX MODELS", 40, screenHeight - 50 + 10, 10, BLUE);
-		DrawText("MOUSE MIDDLE BUTTON to ZOOM OR ROTATE CAMERA", 40, 420, 10, BLUE);
+		DrawText("MOUSE MIDDLE BUTTON to ZOOM OR ROTATE CAMERA", 40, screenHeight - 50 + 20, 10, BLUE);
-		DrawText("UP-DOWN-LEFT-RIGHT KEYS to MOVE CAMERA", 40, 430, 10, BLUE);
+		DrawText("UP-DOWN-LEFT-RIGHT KEYS to MOVE CAMERA", 40, screenHeight - 50 + 30, 10, BLUE);
 		DrawText(TextFormat("File: %s", GetFileName(voxFileNames[currentModel])), 10, 10, 20, GRAY);
 
 		EndDrawing();

examples/models/models_mesh_generation.c

@@ -26,8 +26,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh generation");
 
@@ -78,6 +78,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if(IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, CAMERA_ORBITAL);
 
         if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT))
@@ -110,21 +115,21 @@ int main(void)
 
             EndMode3D();
 
-            DrawRectangle(30, 400, 310, 30, Fade(SKYBLUE, 0.5f));
+            DrawRectangle(30, screenHeight - 50, 310, 30, Fade(SKYBLUE, 0.5f));
-            DrawRectangleLines(30, 400, 310, 30, Fade(DARKBLUE, 0.5f));
+            DrawRectangleLines(30, screenHeight - 50, 310, 30, Fade(DARKBLUE, 0.5f));
-            DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL MODELS", 40, 410, 10, BLUE);
+            DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL MODELS", 40, screenHeight - 50 + 10, 10, BLUE);
 
             switch (currentModel)
             {
-                case 0: DrawText("PLANE", 680, 10, 20, DARKBLUE); break;
+                case 0: DrawText("PLANE", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 1: DrawText("CUBE", 680, 10, 20, DARKBLUE); break;
+                case 1: DrawText("CUBE", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 2: DrawText("SPHERE", 680, 10, 20, DARKBLUE); break;
+                case 2: DrawText("SPHERE", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 3: DrawText("HEMISPHERE", 640, 10, 20, DARKBLUE); break;
+                case 3: DrawText("HEMISPHERE", screenWidth - 160, 10, 20, DARKBLUE); break;
-                case 4: DrawText("CYLINDER", 680, 10, 20, DARKBLUE); break;
+                case 4: DrawText("CYLINDER", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 5: DrawText("TORUS", 680, 10, 20, DARKBLUE); break;
+                case 5: DrawText("TORUS", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 6: DrawText("KNOT", 680, 10, 20, DARKBLUE); break;
+                case 6: DrawText("KNOT", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 7: DrawText("POLY", 680, 10, 20, DARKBLUE); break;
+                case 7: DrawText("POLY", screenWidth - 120, 10, 20, DARKBLUE); break;
-                case 8: DrawText("Custom (triangle)", 580, 10, 20, DARKBLUE); break;
+                case 8: DrawText("Custom (triangle)", screenWidth - 220, 10, 20, DARKBLUE); break;
                 default: break;
             }
 

examples/models/models_mesh_picking.c

@@ -27,8 +27,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh picking");
 
@@ -73,6 +73,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         if (IsCursorHidden()) UpdateCamera(&camera, CAMERA_FIRST_PERSON);          // Update camera
 
         // Toggle camera controls
@@ -226,7 +231,7 @@ int main(void)
                     DrawText(TextFormat("Barycenter: %3.2f %3.2f %3.2f",  bary.x, bary.y, bary.z), 10, ypos + 45, 10, BLACK);
             }
 
-            DrawText("Right click mouse to toggle camera controls", 10, 430, 10, GRAY);
+            DrawText("Right click mouse to toggle camera controls", 10, screenHeight - 20, 10, GRAY);
 
             DrawText("(c) Turret 3D model by Alberto Cano", screenWidth - 200, screenHeight - 20, 10, GRAY);
 

examples/models/models_point_rendering.c

@@ -33,8 +33,8 @@ int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
     
     InitWindow(screenWidth, screenHeight, "raylib [models] example - point rendering");
 
@@ -62,6 +62,11 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, CAMERA_ORBITAL);
 
         if (IsKeyPressed(KEY_SPACE)) useDrawModelPoints = !useDrawModelPoints;

examples/models/models_rlgl_solar_system.c

@@ -32,8 +32,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     const float sunRadius = 4.0f;
     const float earthRadius = 0.6f;
@@ -66,6 +66,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, CAMERA_ORBITAL);
 
         earthRotation += (5.0f*rotationSpeed);
@@ -112,7 +117,7 @@ int main(void)
 
             EndMode3D();
 
-            DrawText("EARTH ORBITING AROUND THE SUN!", 400, 10, 20, MAROON);
+            DrawText("EARTH ORBITING AROUND THE SUN!", screenWidth - 400, 10, 20, MAROON);
             DrawFPS(10, 10);
 
         EndDrawing();

examples/models/models_yaw_pitch_roll.c

@@ -26,8 +26,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     //SetConfigFlags(FLAG_MSAA_4X_HINT | FLAG_WINDOW_HIGHDPI);
     InitWindow(screenWidth, screenHeight, "raylib [models] example - plane rotations (yaw, pitch, roll)");
@@ -55,6 +55,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if(IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         // Plane pitch (x-axis) controls
         if (IsKeyDown(KEY_DOWN)) pitch += 0.6f;
         else if (IsKeyDown(KEY_UP)) pitch -= 0.6f;
@@ -101,11 +106,11 @@ int main(void)
             EndMode3D();
 
             // Draw controls info
-            DrawRectangle(30, 370, 260, 70, Fade(GREEN, 0.5f));
+            DrawRectangle(30, screenHeight - 80, 260, 70, Fade(GREEN, 0.5f));
-            DrawRectangleLines(30, 370, 260, 70, Fade(DARKGREEN, 0.5f));
+            DrawRectangleLines(30, screenHeight - 80, 260, 70, Fade(DARKGREEN, 0.5f));
-            DrawText("Pitch controlled with: KEY_UP / KEY_DOWN", 40, 380, 10, DARKGRAY);
+            DrawText("Pitch controlled with: KEY_UP / KEY_DOWN", 40, screenHeight - 70, 10, DARKGRAY);
-            DrawText("Roll controlled with: KEY_LEFT / KEY_RIGHT", 40, 400, 10, DARKGRAY);
+            DrawText("Roll controlled with: KEY_LEFT / KEY_RIGHT", 40, screenHeight - 50, 10, DARKGRAY);
-            DrawText("Yaw controlled with: KEY_A / KEY_S", 40, 420, 10, DARKGRAY);
+            DrawText("Yaw controlled with: KEY_A / KEY_S", 40, screenHeight - 30, 10, DARKGRAY);
 
             DrawText("(c) WWI Plane Model created by GiaHanLam", screenWidth - 240, screenHeight - 20, 10, DARKGRAY);
 

examples/shaders/resources/shaders/glsl100/swirl.fs

@@ -12,19 +12,15 @@ uniform vec4 colDiffuse;
 
 // NOTE: Add your custom variables here
 
-// NOTE: Render size values should be passed from code
-const float renderWidth = 800.0;
-const float renderHeight = 450.0;
-
 float radius = 250.0;
 float angle = 0.8;
 
+uniform vec2 size = { 800.0, 450.0 };
 uniform vec2 center;
 
 void main()
 {
-    vec2 texSize = vec2(renderWidth, renderHeight);
+    vec2 tc = fragTexCoord*size;
-    vec2 tc = fragTexCoord*texSize;
     tc -= center;
 
     float dist = length(tc);
@@ -40,7 +36,7 @@ void main()
     }
 
     tc += center;
-    vec4 color = texture2D(texture0, tc/texSize)*colDiffuse*fragColor;;
+    vec4 color = texture2D(texture0, tc/size)*colDiffuse*fragColor;;
 
     gl_FragColor = vec4(color.rgb, 1.0);
 }

examples/shaders/resources/shaders/glsl120/swirl.fs

@@ -10,19 +10,15 @@ uniform vec4 colDiffuse;
 
 // NOTE: Add your custom variables here
 
-// NOTE: Render size values should be passed from code
-const float renderWidth = 800;
-const float renderHeight = 450;
-
 float radius = 250.0;
 float angle = 0.8;
 
+uniform vec2 size   = vec2(800.0, 450.0);
 uniform vec2 center;
 
 void main()
 {
-    vec2 texSize = vec2(renderWidth, renderHeight);
+    vec2 tc = fragTexCoord*size;
-    vec2 tc = fragTexCoord*texSize;
     tc -= center;
 
     float dist = length(tc);
@@ -38,7 +34,7 @@ void main()
     }
 
     tc += center;
-    vec4 color = texture2D(texture0, tc/texSize)*colDiffuse*fragColor;;
+    vec4 color = texture2D(texture0, tc/size)*colDiffuse*fragColor;;
 
     gl_FragColor = vec4(color.rgb, 1.0);;
 }

examples/shaders/resources/shaders/glsl330/swirl.fs

@@ -13,19 +13,15 @@ out vec4 finalColor;
 
 // NOTE: Add your custom variables here
 
-// NOTE: Render size values should be passed from code
-const float renderWidth = 800;
-const float renderHeight = 450;
-
 float radius = 250.0;
 float angle = 0.8;
 
+uniform vec2 size   = vec2(800.0, 450.0);
 uniform vec2 center = vec2(200.0, 200.0);
 
 void main()
 {
-    vec2 texSize = vec2(renderWidth, renderHeight);
+    vec2 tc = fragTexCoord*size;
-    vec2 tc = fragTexCoord*texSize;
     tc -= center;
 
     float dist = length(tc);
@@ -41,7 +37,7 @@ void main()
     }
 
     tc += center;
-    vec4 color = texture(texture0, tc/texSize)*colDiffuse*fragColor;;
+    vec4 color = texture(texture0, tc/size)*colDiffuse*fragColor;;
 
     finalColor = vec4(color.rgb, 1.0);;
 }

examples/shaders/shaders_basic_pbr.c

@@ -82,8 +82,8 @@ int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - basic pbr");
@@ -202,6 +202,12 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+
+	}
         UpdateCamera(&camera, CAMERA_ORBITAL);
 
         // Update the shader with the camera view vector (points towards { 0.0f, 0.0f, 0.0f })

examples/shaders/shaders_custom_uniform.c

@@ -35,8 +35,10 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
+    float swirlSize[2]   = { (float)screenWidth, (float)screenHeight };
+    float swirlCenter[2] = { (float)screenWidth/2, (float)screenHeight/2 };
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
 
@@ -62,12 +64,11 @@ int main(void)
 
     // Get variable (uniform) location on the shader to connect with the program
     // NOTE: If uniform variable could not be found in the shader, function returns -1
+    int swirlSizeLoc = GetShaderLocation(shader, "size");
     int swirlCenterLoc = GetShaderLocation(shader, "center");
 
-    float swirlCenter[2] = { (float)screenWidth/2, (float)screenHeight/2 };
-
     // Create a RenderTexture2D to be used for render to texture
-    RenderTexture2D target = LoadRenderTexture(screenWidth, screenHeight);
+    RenderTexture2D target;
 
     SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -75,15 +76,27 @@ int main(void)
     // Main game loop
     while (!WindowShouldClose())        // Detect window close button or ESC key
     {
+    	if (IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
+        // Create a RenderTexture2D to be used for render to texture
+        UnloadRenderTexture(target);
+        target = LoadRenderTexture(screenWidth, screenHeight);
+
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera, CAMERA_ORBITAL);
         
         Vector2 mousePosition = GetMousePosition();
 
+        swirlSize[0] = screenWidth;
+        swirlSize[1] = screenHeight;
+        SetShaderValue(shader, swirlSizeLoc, swirlSize, SHADER_UNIFORM_VEC2);
+
         swirlCenter[0] = mousePosition.x;
         swirlCenter[1] = screenHeight - mousePosition.y;
-
         // Send new value to the shader to be used on drawing
         SetShaderValue(shader, swirlCenterLoc, swirlCenter, SHADER_UNIFORM_VEC2);
         //----------------------------------------------------------------------------------
@@ -98,7 +111,7 @@ int main(void)
                 DrawGrid(10, 1.0f);     // Draw a grid
             EndMode3D();                // End 3d mode drawing, returns to orthographic 2d mode
 
-            DrawText("TEXT DRAWN IN RENDER TEXTURE", 200, 10, 30, RED);
+            DrawText("TEXT DRAWN IN RENDER TEXTURE", screenWidth - 600, 10, 30, RED);
         EndTextureMode();               // End drawing to texture (now we have a texture available for next passes)
 
         BeginDrawing();
@@ -107,7 +120,7 @@ int main(void)
             // Enable shader using the custom uniform
             BeginShaderMode(shader);
                 // NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
-                DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height }, (Vector2){ 0, 0 }, WHITE);
+                DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)screenWidth, (float)-screenHeight }, (Vector2){ 0, 0 }, WHITE);
             EndShaderMode();
 
             // Draw some 2d text over drawn texture

examples/shaders/shaders_hot_reloading.c

@@ -34,8 +34,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - hot reloading");
 
@@ -51,9 +51,6 @@ int main(void)
     int mouseLoc = GetShaderLocation(shader, "mouse");
     int timeLoc = GetShaderLocation(shader, "time");
 
-    float resolution[2] = { (float)screenWidth, (float)screenHeight };
-    SetShaderValue(shader, resolutionLoc, resolution, SHADER_UNIFORM_VEC2);
-
     float totalTime = 0.0f;
     bool shaderAutoReloading = false;
 
@@ -65,6 +62,14 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
+        float resolution[2] = { (float)screenWidth, (float)screenHeight };
+        SetShaderValue(shader, resolutionLoc, resolution, SHADER_UNIFORM_VEC2);
+
         totalTime += GetFrameTime();
         Vector2 mouse = GetMousePosition();
         float mousePos[2] = { mouse.x, mouse.y };
@@ -120,7 +125,7 @@ int main(void)
                      shaderAutoReloading? "AUTO" : "MANUAL"), 10, 10, 10, shaderAutoReloading? RED : BLACK);
             if (!shaderAutoReloading) DrawText("MOUSE CLICK to SHADER RE-LOADING", 10, 30, 10, BLACK);
 
-            DrawText(TextFormat("Shader last modification: %s", asctime(localtime(&fragShaderFileModTime))), 10, 430, 10, BLACK);
+            DrawText(TextFormat("Shader last modification: %s", asctime(localtime(&fragShaderFileModTime))), 10, screenHeight - 20, 10, BLACK);
 
         EndDrawing();
         //----------------------------------------------------------------------------------

examples/shaders/shaders_hybrid_render.c

@@ -49,8 +49,9 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
+    Vector2 screenCenter = {.x = screenWidth/2.0f, .y = screenHeight/2.0f};
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - write depth buffer");
 
@@ -69,12 +70,6 @@ int main(void)
     marchLocs.camDir = GetShaderLocation(shdrRaymarch, "camDir");
     marchLocs.screenCenter = GetShaderLocation(shdrRaymarch, "screenCenter");
 
-    // Transfer screenCenter position to shader. Which is used to calculate ray direction. 
-    Vector2 screenCenter = {.x = screenWidth/2.0f, .y = screenHeight/2.0f};
-    SetShaderValue(shdrRaymarch, marchLocs.screenCenter , &screenCenter , SHADER_UNIFORM_VEC2);
-
-    // Use Customized function to create writable depth texture buffer
-    RenderTexture2D target = LoadRenderTextureDepthTex(screenWidth, screenHeight);
 
     // Define the camera to look into our 3d world
     Camera camera = {
@@ -87,6 +82,7 @@ int main(void)
     
     // Camera FOV is pre-calculated in the camera Distance.
     float camDist = 1.0f/(tanf(camera.fovy*0.5f*DEG2RAD));
+    RenderTexture2D target = LoadRenderTextureDepthTex(screenWidth, screenHeight);
     
     SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -96,6 +92,18 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+        // Use Customized function to create writable depth texture buffer
+        // Transfer screenCenter position to shader. Which is used to calculate ray direction.
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+        	screenCenter.x = screenWidth/2.0f;
+		screenCenter.y = screenHeight/2.0f;
+		UnloadRenderTexture(target);
+		target = LoadRenderTextureDepthTex(screenWidth, screenHeight);
+	}
+        SetShaderValue(shdrRaymarch, marchLocs.screenCenter , &screenCenter , SHADER_UNIFORM_VEC2);
         UpdateCamera(&camera, CAMERA_ORBITAL);
 
         // Update Camera Postion in the ray march shader.
@@ -133,7 +141,6 @@ int main(void)
         // Draw into screen our custom render texture 
         BeginDrawing();
             ClearBackground(RAYWHITE);
-        
             DrawTextureRec(target.texture, (Rectangle) { 0, 0, (float)screenWidth, (float)-screenHeight }, (Vector2) { 0, 0 }, WHITE);
             DrawFPS(10, 10);
         EndDrawing();

examples/shaders/shaders_model_shader.c

@@ -35,8 +35,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
 
@@ -71,6 +71,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, CAMERA_FREE);
         //----------------------------------------------------------------------------------
 

examples/shaders/shaders_postprocessing.c

@@ -69,8 +69,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);      // Enable Multi Sampling Anti Aliasing 4x (if available)
 
@@ -133,6 +133,13 @@ int main(void)
 
         // Draw
         //----------------------------------------------------------------------------------
+	if(IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+		UnloadRenderTexture(target);
+		target = LoadRenderTexture(screenWidth, screenHeight);
+	}
         BeginTextureMode(target);       // Enable drawing to texture
             ClearBackground(RAYWHITE);  // Clear texture background
 
@@ -148,7 +155,7 @@ int main(void)
             // Render generated texture using selected postprocessing shader
             BeginShaderMode(shaders[currentShader]);
                 // NOTE: Render texture must be y-flipped due to default OpenGL coordinates (left-bottom)
-                DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)target.texture.width, (float)-target.texture.height }, (Vector2){ 0, 0 }, WHITE);
+                DrawTextureRec(target.texture, (Rectangle){ 0, 0, (float)screenWidth, (float)-screenHeight }, (Vector2){0, 0}, WHITE);
             EndShaderMode();
 
             // Draw 2d shapes and text over drawn texture
@@ -158,7 +165,7 @@ int main(void)
             DrawText("CURRENT POSTPRO SHADER:", 10, 15, 20, BLACK);
             DrawText(postproShaderText[currentShader], 330, 15, 20, RED);
             DrawText("< >", 540, 10, 30, DARKBLUE);
-            DrawFPS(700, 15);
+            DrawFPS(screenWidth - 100, 15);
         EndDrawing();
         //----------------------------------------------------------------------------------
     }

examples/shaders/shaders_rounded_rectangle.c

@@ -68,8 +68,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     const Color rectangleColor = BLUE;
     const Color shadowColor = DARKBLUE;
@@ -100,6 +100,13 @@ int main(void)
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
+    	// Update
+	//----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
@@ -162,12 +169,10 @@ int main(void)
                 DrawRectangle(0, 0, screenWidth, screenHeight, WHITE);
             EndShaderMode();
 
-
-
             // Draw one more rectangle with all three colors
-            rec = (Rectangle){ 240, 80, 500, 300 };
+            rec = (Rectangle){ 240, 80, screenWidth - 300, screenHeight - 150 };
-            DrawRectangleLines((int)rec.x - 30, (int)rec.y - 30, (int)rec.width + 60, (int)rec.height + 60, DARKGRAY);
+            DrawRectangleLines(rec.x - 30, rec.y - 30, rec.width + 60, rec.height + 60, DARKGRAY);
-            DrawText("Rectangle with all three combined", (int)rec.x - 30, (int)rec.y - 45, 10, DARKGRAY);
+            DrawText("Rectangle with all three combined", rec.x - 30, rec.y - 45, 10, DARKGRAY);
 
             rec.y = screenHeight - rec.y - rec.height;
             SetShaderValue(shader, roundedRectangle.rectangleLoc, (float[]){ rec.x, rec.y, rec.width, rec.height }, SHADER_UNIFORM_VEC4);

examples/shaders/shaders_shadowmap.c

@@ -38,8 +38,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     // Shadows are a HUGE topic, and this example shows an extremely simple implementation of the shadowmapping algorithm,
@@ -101,6 +101,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         float dt = GetFrameTime();
 
         Vector3 cameraPos = cam.position;

examples/shaders/shaders_spotlight.c

@@ -62,6 +62,9 @@ typedef struct Star {
     Vector2 speed;
 } Star;
 
+int screenWidth = 800;
+int screenHeight = 450;
+
 static void UpdateStar(Star *s);
 static void ResetStar(Star *s);
 
@@ -72,9 +75,6 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
-    const int screenHeight = 450;
-
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - shader spotlight");
     HideCursor();
 
@@ -85,10 +85,8 @@ int main(void)
     for (int n = 0; n < MAX_STARS; n++) ResetStar(&stars[n]);
 
     // Progress all the stars on, so they don't all start in the centre
-    for (int m = 0; m < screenWidth/2.0; m++)
+    for (int m = 0; m < screenWidth * 0.5; m++)
-    {
         for (int n = 0; n < MAX_STARS; n++) UpdateStar(&stars[n]);
-    }
 
     int frameCounter = 0;
 
@@ -117,7 +115,7 @@ int main(void)
     // Tell the shader how wide the screen is so we can have
     // a pitch black half and a dimly lit half.
     unsigned int wLoc = GetShaderLocation(shdrSpot, "screenWidth");
-    float sw = (float)GetScreenWidth();
+    float sw = (float)screenWidth;
     SetShaderValue(shdrSpot, wLoc, &sw, SHADER_UNIFORM_FLOAT);
 
     // Randomize the locations and velocities of the spotlights
@@ -150,8 +148,16 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         frameCounter++;
 
+        sw = (float)screenWidth;
+        SetShaderValue(shdrSpot, wLoc, &sw, SHADER_UNIFORM_FLOAT);
+
         // Move the stars, resetting them if the go offscreen
         for (int n = 0; n < MAX_STARS; n++) UpdateStar(&stars[n]);
 
@@ -194,8 +200,8 @@ int main(void)
             for (int i = 0; i < 16; i++)
             {
                 DrawTexture(texRay,
-                    (int)((screenWidth/2.0f) + cos((frameCounter + i*8)/51.45f)*(screenWidth/2.2f) - 32),
+                    (int)((screenWidth * 0.5f) + cos((frameCounter + i*8)/51.45f)*(screenWidth/2.2f) - 32),
-                    (int)((screenHeight/2.0f) + sin((frameCounter + i*8)/17.87f)*(screenHeight/4.2f)), WHITE);
+                    (int)((screenHeight * 0.5f) + sin((frameCounter + i*8)/17.87f)*(screenHeight/4.2f)), WHITE);
             }
 
             // Draw spot lights
@@ -210,8 +216,8 @@ int main(void)
             DrawFPS(10, 10);
 
             DrawText("Move the mouse!", 10, 30, 20, GREEN);
-            DrawText("Pitch Black", (int)(screenWidth*0.2f), screenHeight/2, 20, GREEN);
+            DrawText("Pitch Black", (int)(screenWidth*0.2f), screenHeight * 0.5f, 20, GREEN);
-            DrawText("Dark", (int)(screenWidth*.66f), screenHeight/2, 20, GREEN);
+            DrawText("Dark", (int)(screenWidth*.66f), screenHeight * 0.5f, 20, GREEN);
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -231,7 +237,7 @@ int main(void)
 
 static void ResetStar(Star *s)
 {
-    s->position = (Vector2){ GetScreenWidth()/2.0f, GetScreenHeight()/2.0f };
+    s->position = (Vector2){ screenWidth * 0.5f, screenHeight * 0.5f };
 
     do
     {
@@ -247,8 +253,8 @@ static void UpdateStar(Star *s)
 {
     s->position = Vector2Add(s->position, s->speed);
 
-    if ((s->position.x < 0) || (s->position.x > GetScreenWidth()) ||
+    if ((s->position.x < 0) || (s->position.x > screenWidth) ||
-        (s->position.y < 0) || (s->position.y > GetScreenHeight()))
+        (s->position.y < 0) || (s->position.y > screenHeight))
     {
         ResetStar(s);
     }

examples/shaders/shaders_write_depth.c

@@ -41,8 +41,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shaders] example - write depth buffer");
 
@@ -69,11 +69,18 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, CAMERA_ORBITAL);
         //----------------------------------------------------------------------------------
         
         // Draw
         //----------------------------------------------------------------------------------
+        UnloadRenderTexture(target);
+		    target = LoadRenderTextureDepthTex(screenWidth, screenHeight);
         // Draw into our custom render texture (framebuffer)
         BeginTextureMode(target);
             ClearBackground(WHITE);

examples/shapes/shapes_bouncing_ball.c

@@ -22,13 +22,13 @@ int main(void)
 {
     // Initialization
     //---------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - bouncing ball");
 
-    Vector2 ballPosition = { GetScreenWidth()/2.0f, GetScreenHeight()/2.0f };
+    Vector2 ballPosition = { screenWidth/2.0f, screenHeight/2.0f };
     Vector2 ballSpeed = { 5.0f, 4.0f };
     int ballRadius = 20;
 
@@ -51,8 +51,8 @@ int main(void)
             ballPosition.y += ballSpeed.y;
 
             // Check walls collision for bouncing
-            if ((ballPosition.x >= (GetScreenWidth() - ballRadius)) || (ballPosition.x <= ballRadius)) ballSpeed.x *= -1.0f;
+            if ((ballPosition.x >= (screenWidth - ballRadius)) || (ballPosition.x <= ballRadius)) ballSpeed.x *= -1.0f;
-            if ((ballPosition.y >= (GetScreenHeight() - ballRadius)) || (ballPosition.y <= ballRadius)) ballSpeed.y *= -1.0f;
+            if ((ballPosition.y >= (screenHeight - ballRadius)) || (ballPosition.y <= ballRadius)) ballSpeed.y *= -1.0f;
         }
         else framesCounter++;
         //-----------------------------------------------------
@@ -64,10 +64,10 @@ int main(void)
             ClearBackground(RAYWHITE);
 
             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, screenHeight - 25, 20, LIGHTGRAY);
 
             // On pause, we draw a blinking message
-            if (pause && ((framesCounter/30)%2)) DrawText("PAUSED", 350, 200, 30, GRAY);
+            if (pause && ((framesCounter/30)%2)) DrawText("PAUSED", (screenWidth - 100)/2, (screenHeight- 50)/2, 30, GRAY);
 
             DrawFPS(10, 10);
 

examples/shapes/shapes_double_pendulum.c

@@ -25,9 +25,6 @@
 #define SCREEN_WIDTH 800
 #define SCREEN_HEIGHT 450
 
-#define CENTER_X SCREEN_WIDTH * 0.5
-#define CENTER_Y SCREEN_HEIGHT * 0.5 - 100
-
 // Constant for Simulation
 #define SIMULATION_STEPS 30
 #define G 9.81
@@ -37,7 +34,7 @@
 //----------------------------------------------------------------------------------
 static Vector2 CalculatePendulumEndPoint(float l, float theta);
 static Vector2 CalculateDoublePendulumEndPoint(float l1, float theta1, float l2, float theta2);
-
+static Vector2 CalculateCenter(Vector2 screenSize) { return (Vector2){ screenSize.x * 0.5, screenSize.y * 0.5 - 100 }; }
 //------------------------------------------------------------------------------------
 // Program main entry point
 //------------------------------------------------------------------------------------
@@ -47,6 +44,8 @@ int main(void)
     //--------------------------------------------------------------------------------------
     SetConfigFlags(FLAG_WINDOW_HIGHDPI);
     InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "raylib [shapes] example - Double Pendulum");
+    Vector2 screenSize   = { GetScreenWidth(), GetScreenHeight() };
+    Vector2 screenCenter = CalculateCenter(screenSize);
 
     // Simulation Paramters
     //--------------------------------------------------------------------------------------
@@ -56,8 +55,8 @@ int main(void)
     float totalM = m1 + m2;
 
     Vector2 previousPosition = CalculateDoublePendulumEndPoint(l1, theta1, l2, theta2);
-    previousPosition.x += CENTER_X;
+    previousPosition.x += screenCenter.x;
-    previousPosition.y += CENTER_Y;
+    previousPosition.y += screenCenter.y;
 
     // Scale length
     float L1 = l1 * lengthScaler;
@@ -70,7 +69,7 @@ int main(void)
     
     // Create Framebuffer
     //--------------------------------------------------------------------------------------
-    RenderTexture2D target = LoadRenderTexture(SCREEN_WIDTH, SCREEN_HEIGHT);
+    RenderTexture2D target = LoadRenderTexture(screenSize.x, screenSize.y);
     SetTextureFilter(target.texture, TEXTURE_FILTER_BILINEAR);
 
     SetTargetFPS(60);
@@ -82,6 +81,16 @@ int main(void)
         // Update
         float dt = GetFrameTime();
         float step = dt / SIMULATION_STEPS, step2 = step * step;
+	if(IsWindowResized())
+	{
+		// Update screen dimensions
+		screenSize.x = GetScreenWidth();
+		screenSize.y = GetScreenHeight();
+		screenCenter = CalculateCenter(screenSize);
+		UnloadRenderTexture(target);
+		target = LoadRenderTexture(screenSize.x, screenSize.y);
+		SetTextureFilter(target.texture, TEXTURE_FILTER_BILINEAR);
+	}
 
         // Update Physics - larger steps = better approximation
         //----------------------------------------------------------------------------------
@@ -115,15 +124,15 @@ int main(void)
 
         // Calculate position
         Vector2 currentPosition = CalculateDoublePendulumEndPoint(l1, theta1, l2, theta2);
-        currentPosition.x += CENTER_X;
+        currentPosition.x += screenCenter.x;
-        currentPosition.y += CENTER_Y;
+        currentPosition.y += screenCenter.y;
 
         // Draw to framebuffer
         //----------------------------------------------------------------------------------
         BeginTextureMode(target);
 
             // Draw a transparent rectangle - smaller alpha = longer trails
-            DrawRectangle(0, 0, SCREEN_WIDTH, SCREEN_HEIGHT, Fade(BLACK, fateAlpha));
+            DrawRectangle(0, 0, screenSize.x, screenSize.y, Fade(BLACK, fateAlpha));
             
             // Draw trail
             DrawCircleV(previousPosition, trailThick, RED);
@@ -146,11 +155,11 @@ int main(void)
                              (Vector2){ 0, 0 }, WHITE);
 
             // Draw Double Pendulum
-            DrawRectanglePro((Rectangle){ CENTER_X, CENTER_Y, 10 * l1, lineThick },
+            DrawRectanglePro((Rectangle){ screenCenter.x, screenCenter.y, 10 * l1, lineThick },
                              (Vector2){0, lineThick * 0.5}, 90 - RAD2DEG * theta1, RAYWHITE);
 
             Vector2 endpoint1 = CalculatePendulumEndPoint(l1, theta1);
-            DrawRectanglePro((Rectangle){ CENTER_X + endpoint1.x, CENTER_Y + endpoint1.y, 10 * l2, lineThick },
+            DrawRectanglePro((Rectangle){ screenCenter.x + endpoint1.x, screenCenter.y + endpoint1.y, 10 * l2, lineThick },
                              (Vector2){0, lineThick * 0.5}, 90 - RAD2DEG * theta2, RAYWHITE);
 
         EndDrawing();

examples/shapes/shapes_easings_ball_anim.c

@@ -24,8 +24,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - easings ball anim");
 
@@ -45,6 +45,15 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+		if(state > 0)
+            		ballPositionX = (int)EaseElasticOut((float)120, -100, screenWidth/2.0f + 100, 120);
+		if(state > 1)
+            		ballRadius = (int)EaseElasticIn((float)200, 20, screenWidth/2.0f + 100, 200);
+	}
         if (state == 0)             // Move ball position X with easing
         {
             framesCounter++;
@@ -59,7 +68,7 @@ int main(void)
         else if (state == 1)        // Increase ball radius with easing
         {
             framesCounter++;
-            ballRadius = (int)EaseElasticIn((float)framesCounter, 20, 500, 200);
+            ballRadius = (int)EaseElasticIn((float)framesCounter, 20, screenWidth/2.0f + 100, 200);
 
             if (framesCounter >= 200)
             {
@@ -100,9 +109,9 @@ int main(void)
             ClearBackground(RAYWHITE);
 
             if (state >= 2) DrawRectangle(0, 0, screenWidth, screenHeight, GREEN);
-            DrawCircle(ballPositionX, 200, (float)ballRadius, Fade(RED, 1.0f - ballAlpha));
+            DrawCircle(ballPositionX, screenHeight / 2, (float)ballRadius, Fade(RED, 1.0f - ballAlpha));
 
-            if (state == 3) DrawText("PRESS [ENTER] TO PLAY AGAIN!", 240, 200, 20, BLACK);
+            if (state == 3) DrawText("PRESS [ENTER] TO PLAY AGAIN!", screenWidth/2 - 140, (screenHeight/2 - 10), 20, BLACK);
 
         EndDrawing();
         //----------------------------------------------------------------------------------

examples/shapes/shapes_following_eyes.c

@@ -24,8 +24,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - following eyes");
 
@@ -46,6 +46,16 @@ int main(void)
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
+        if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight(); 
+	}
+        scleraLeftPosition.x = screenWidth/2.0f - 100.0f;
+		scleraLeftPosition.y = screenHeight/2.0f;
+        scleraRightPosition.x = screenWidth/2.0f + 100.0f;
+		scleraRightPosition.y = screenHeight/2.0f;
+
         // Update
         //----------------------------------------------------------------------------------
         irisLeftPosition = GetMousePosition();

examples/shapes/shapes_logo_raylib.c

@@ -22,8 +22,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes");
 
@@ -37,7 +37,11 @@ int main(void)
         //----------------------------------------------------------------------------------
         // TODO: Update your variables here
         //----------------------------------------------------------------------------------
-
+	if (IsWindowResized())
+	{
+		screenWidth = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         // Draw
         //----------------------------------------------------------------------------------
         BeginDrawing();
@@ -48,7 +52,7 @@ int main(void)
             DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, RAYWHITE);
             DrawText("raylib", screenWidth/2 - 44, screenHeight/2 + 48, 50, BLACK);
 
-            DrawText("this is NOT a texture!", 350, 370, 10, GRAY);
+            DrawText("this is NOT a texture!", screenWidth/2 - 50, screenHeight/2 + 145, 10, GRAY);
 
         EndDrawing();
         //----------------------------------------------------------------------------------

examples/shapes/shapes_logo_raylib_anim.c

@@ -22,8 +22,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo animation");
 
@@ -48,6 +48,14 @@ int main(void)
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
+    	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
+        logoPositionX = screenWidth/2 - 128;
+        logoPositionY = screenHeight/2 - 128;
+
         // Update
         //----------------------------------------------------------------------------------
         if (state == 0)                 // State 0: Small box blinking
@@ -145,13 +153,13 @@ int main(void)
                 DrawRectangle(logoPositionX + 240, logoPositionY + 16, 16, rightSideRecHeight - 32, Fade(BLACK, alpha));
                 DrawRectangle(logoPositionX, logoPositionY + 240, bottomSideRecWidth, 16, Fade(BLACK, alpha));
 
-                DrawRectangle(GetScreenWidth()/2 - 112, GetScreenHeight()/2 - 112, 224, 224, Fade(RAYWHITE, alpha));
+                DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, Fade(RAYWHITE, alpha));
 
-                DrawText(TextSubtext("raylib", 0, lettersCount), GetScreenWidth()/2 - 44, GetScreenHeight()/2 + 48, 50, Fade(BLACK, alpha));
+                DrawText(TextSubtext("raylib", 0, lettersCount), screenWidth/2 - 44, screenHeight/2 + 48, 50, Fade(BLACK, alpha));
             }
             else if (state == 4)
             {
-                DrawText("[R] REPLAY", 340, 200, 20, GRAY);
+                DrawText("[R] REPLAY", screenWidth/2 - 60, screenHeight/2 - 25, 20, GRAY);
             }
 
         EndDrawing();

examples/text/text_draw_3d.c

@@ -81,8 +81,8 @@ int main(void)
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    const int screenWidth = 800;
+    int screenWidth = 800;
-    const int screenHeight = 450;
+    int screenHeight = 450;
 
     SetConfigFlags(FLAG_MSAA_4X_HINT|FLAG_VSYNC_HINT);
     InitWindow(screenWidth, screenHeight, "raylib [text] example - draw 2D text in 3D");
@@ -143,6 +143,11 @@ int main(void)
     {
         // Update
         //----------------------------------------------------------------------------------
+	if (IsWindowResized())
+	{
+		screenWidth  = GetScreenWidth();
+		screenHeight = GetScreenHeight();
+	}
         UpdateCamera(&camera, camera_mode);
         
         // Handle font files dropped