Improved some examples

examples/models/models_mesh_generation.c

@@ -11,9 +11,8 @@
 
 #include "raylib.h"
 
-//------------------------------------------------------------------------------------
+#define NUM_MODELS  7      // We generate 7 parametric 3d shapes
-// Program main entry point
+
-//------------------------------------------------------------------------------------
 int main()
 {
     // Initialization
@@ -23,31 +22,33 @@ int main()
 
     InitWindow(screenWidth, screenHeight, "raylib [models] example - mesh generation");
     
-    //Model model = LoadModelFromMesh(GenMeshPlane(2, 2, 5, 5));            // Texture coordinates must be divided by resX, resZ
+    // We generate a checked image for texturing
-    //Model model = LoadModelFromMesh(GenMeshCube(2.0f, 1.0f, 2.0f));       // OK!
+    Image checked = GenImageChecked(2, 2, 1, 1, RED, GREEN);
-    //Model model = LoadModelFromMesh(GenMeshSphere(2, 32, 32));              // OK! (par_shapes)
+    Texture2D texture = LoadTextureFromImage(checked);
-    //Model model = LoadModelFromMesh(GenMeshHemiSphere(2, 16, 16));              // OK! (par_shapes)
+    UnloadImage(checked);
-    //Model model = LoadModelFromMesh(GenMeshCylinder(1, 2, 16));              // OK! (par_shapes)
-    Model model = LoadModelFromMesh(GenMeshTorus(0.25f, 4.0f, 16, 32));
-    //Model model = LoadModelFromMesh(GenMeshKnot(1.0f, 2.0f, 16, 128));
-    model.material.maps[MAP_DIFFUSE].texture = LoadTexture("resources/pixels.png");
     
-    // Debug information
+    Model models[NUM_MODELS];
-    /*
+    
-    printf("model.mesh.vertexCount: %i\n", model.mesh.vertexCount);
+    models[0] = LoadModelFromMesh(GenMeshPlane(2, 2, 5, 5));
-    printf("model.mesh.triangleCount: %i\n", model.mesh.triangleCount);
+    models[1] = LoadModelFromMesh(GenMeshCube(2.0f, 1.0f, 2.0f));
-    printf("model.mesh.vboId (position): %i\n", model.mesh.vboId[0]);
+    models[2] = LoadModelFromMesh(GenMeshSphere(2, 32, 32));
-    printf("model.mesh.vboId (texcoords): %i\n", model.mesh.vboId[1]);
+    models[3] = LoadModelFromMesh(GenMeshHemiSphere(2, 16, 16));
-    printf("model.mesh.vboId (normals): %i\n", model.mesh.vboId[2]);
+    models[4] = LoadModelFromMesh(GenMeshCylinder(1, 2, 16));
-    printf("model.mesh.vboId (indices): %i\n", model.mesh.vboId[6]);
+    models[5] = LoadModelFromMesh(GenMeshTorus(0.25f, 4.0f, 16, 32));
-    */
+    models[6] = LoadModelFromMesh(GenMeshKnot(1.0f, 2.0f, 16, 128));
+    
+    // Set checked texture as default diffuse component for all models material
+    for (int i = 0; i < NUM_MODELS; i++) models[i].material.maps[MAP_DIFFUSE].texture = texture;
 
     // Define the camera to look into our 3d world
     Camera camera = {{ 5.0f, 5.0f, 5.0f }, { 0.0f, 0.0f, 0.0f }, { 0.0f, 1.0f, 0.0f }, 45.0f };
 
+    // Model drawing position
     Vector3 position = { 0.0f, 0.0f, 0.0f };
     
-    SetCameraMode(camera, CAMERA_FREE);         // Set a free camera mode
+    int currentModel = 0;
+    
+    SetCameraMode(camera, CAMERA_ORBITAL);  // Set a orbital camera mode
 
     SetTargetFPS(60);                       // Set our game to run at 60 frames-per-second
     //--------------------------------------------------------------------------------------
@@ -58,6 +59,11 @@ int main()
         // Update
         //----------------------------------------------------------------------------------
         UpdateCamera(&camera);      // Update internal camera and our camera
+        
+        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
+        {
+            currentModel = (currentModel + 1)%NUM_MODELS; // Cycle between the textures
+        }
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -68,19 +74,37 @@ int main()
 
             Begin3dMode(camera);
 
-                DrawModel(model, position, 1.0f, WHITE);
+                DrawModel(models[currentModel], position, 1.0f, WHITE);
 
                 DrawGrid(10, 1.0);
 
             End3dMode();
             
+            DrawRectangle(30, 400, 310, 30, Fade(SKYBLUE, 0.5f));
+            DrawRectangleLines(30, 400, 310, 30, Fade(DARKBLUE, 0.5f));
+            DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL MODELS", 40, 410, 10, BLUE);
+            
+            switch(currentModel)
+            {
+                case 0: DrawText("PLANE", 680, 10, 20, DARKBLUE); break;
+                case 1: DrawText("CUBE", 680, 10, 20, DARKBLUE); break;
+                case 2: DrawText("SPHERE", 680, 10, 20, DARKBLUE); break;
+                case 3: DrawText("HEMISPHERE", 640, 10, 20, DARKBLUE); break;
+                case 4: DrawText("CYLINDER", 680, 10, 20, DARKBLUE); break;
+                case 5: DrawText("TORUS", 680, 10, 20, DARKBLUE); break;
+                case 6: DrawText("KNOT", 680, 10, 20, DARKBLUE); break;
+                default: break;
+            }
+
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    UnloadModel(model);
+    
+    // Unload models data (GPU VRAM)
+    for (int i = 0; i < NUM_MODELS; i++) UnloadModel(models[i]);
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

examples/textures/textures_image_drawing.c

@@ -37,6 +37,14 @@ int main()
     
     UnloadImage(cat);       // Unload image from RAM
     
+    // Load custom font for frawing on image
+    SpriteFont font = LoadSpriteFont("resources/custom_jupiter_crash.png");
+    
+    // Draw over image using custom font
+    ImageDrawTextEx(&parrots, (Vector2){ 300, 230 }, font, "PARROTS & CAT", font.baseSize, -2, WHITE);
+    
+    UnloadSpriteFont(font); // Unload custom spritefont (already drawn used on image)
+
     Texture2D texture = LoadTextureFromImage(parrots);      // Image converted to texture, uploaded to GPU memory (VRAM)
     UnloadImage(parrots);   // Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM
     

examples/textures/textures_image_generation.c

@@ -11,7 +11,7 @@
 
 #include "raylib.h"
 
-#define TEXTURES_NUM 7      // for now we have 7 generation algorithms
+#define NUM_TEXTURES  7      // Currently we have 7 generation algorithms
 
 int main()
 {
@@ -30,7 +30,7 @@ int main()
     Image perlinNoise = GenImagePerlinNoise(screenWidth, screenHeight, 8.f);
     Image cellular = GenImageCellular(screenWidth, screenHeight, 32);
 
-    Texture2D textures[TEXTURES_NUM];
+    Texture2D textures[NUM_TEXTURES];
     textures[0] = LoadTextureFromImage(verticalGradient);
     textures[1] = LoadTextureFromImage(horizontalGradient);
     textures[2] = LoadTextureFromImage(radialGradient);
@@ -39,6 +39,15 @@ int main()
     textures[5] = LoadTextureFromImage(perlinNoise);
     textures[6] = LoadTextureFromImage(cellular);
     
+    // Unload image data (CPU RAM)
+    UnloadImage(verticalGradient);
+    UnloadImage(horizontalGradient);
+    UnloadImage(radialGradient);
+    UnloadImage(checked);
+    UnloadImage(whiteNoise);
+    UnloadImage(perlinNoise);
+    UnloadImage(cellular);
+
     int currentTexture = 0;
     
     SetTargetFPS(60);
@@ -51,7 +60,7 @@ int main()
         //----------------------------------------------------------------------------------
         if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
         {
-            currentTexture = (currentTexture + 1) % TEXTURES_NUM; // cycle between the 5 textures
+            currentTexture = (currentTexture + 1)%NUM_TEXTURES; // Cycle between the textures
         }
         //----------------------------------------------------------------------------------
 
@@ -63,6 +72,22 @@ int main()
             
             DrawTexture(textures[currentTexture], 0, 0, WHITE);
             
+            DrawRectangle(30, 400, 325, 30, Fade(SKYBLUE, 0.5f));
+            DrawRectangleLines(30, 400, 325, 30, Fade(WHITE, 0.5f));
+            DrawText("MOUSE LEFT BUTTON to CYCLE PROCEDURAL TEXTURES", 40, 410, 10, WHITE);
+            
+            switch(currentTexture)
+            {
+                case 0: DrawText("VERTICAL GRADIENT", 560, 10, 20, RAYWHITE); break;
+                case 1: DrawText("HORIZONTAL GRADIENT", 540, 10, 20, RAYWHITE); break;
+                case 2: DrawText("RADIAL GRADIENT", 580, 10, 20, LIGHTGRAY); break;
+                case 3: DrawText("CHECKED", 680, 10, 20, RAYWHITE); break;
+                case 4: DrawText("WHITE NOISE", 640, 10, 20, RED); break;
+                case 5: DrawText("PERLIN NOISE", 630, 10, 20, RAYWHITE); break;
+                case 6: DrawText("CELLULAR", 670, 10, 20, RAYWHITE); break;
+                default: break;
+            }
+            
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
@@ -70,17 +95,8 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
        
-    // Unload image data (CPU RAM)
-    UnloadImage(verticalGradient);
-    UnloadImage(horizontalGradient);
-    UnloadImage(radialGradient);
-    UnloadImage(checked);
-    UnloadImage(whiteNoise);
-    UnloadImage(perlinNoise);
-    UnloadImage(cellular);
-    
     // Unload textures data (GPU VRAM)
-    for (int i = 0; i < TEXTURES_NUM; i++) UnloadTexture(textures[i]);
+    for (int i = 0; i < NUM_TEXTURES; i++) UnloadTexture(textures[i]);
     
     CloseWindow();                // Close window and OpenGL context
     //--------------------------------------------------------------------------------------