examples_model_decals : Fixed unload crash, added buttons (#5306)

examples/models/models_decals.c

@@ -43,8 +43,10 @@ typedef struct MeshBuilder {
 static void AddTriangleToMeshBuilder(MeshBuilder *mb, Vector3 vertices[3]);
 static void FreeMeshBuilder(MeshBuilder *mb);
 static Mesh BuildMesh(MeshBuilder *mb);
-static Mesh GenMeshDecal(Mesh inputMesh, Ray ray);
+static Mesh GenMeshDecal(Model inputModel, Matrix projection, float decalSize, float decalOffset);
 static Vector3 ClipSegment(Vector3 v0, Vector3 v1, Vector3 p, float s);
+#define FreeDecalMeshData() GenMeshDecal((Model){ .meshCount = -1.0f }, (Matrix){ 0 }, 0.0f, 0.0f)
+static bool Button(Rectangle rec, char *label);
 
 //------------------------------------------------------------------------------------
 // Program main entry point
@@ -105,10 +107,6 @@ int main(void)
     decalMaterial.maps[MATERIAL_MAP_DIFFUSE].texture = decalTexture;
     decalMaterial.maps[MATERIAL_MAP_DIFFUSE].color = RAYWHITE;
     
-    // We're going to use these to build up our decal meshes
-    // They'll resize automatically as we go, we'll free them at the end
-    MeshBuilder meshBuilders[2] = { 0 };
-    
     bool showModel = true;
     Model decalModels[MAX_DECALS] = { 0 };
     int decalCount = 0;
@@ -123,8 +121,6 @@ int main(void)
         //----------------------------------------------------------------------------------
         if (IsMouseButtonDown(MOUSE_BUTTON_RIGHT)) UpdateCamera(&camera, CAMERA_THIRD_PERSON);
 
-        if (IsKeyPressed(KEY_SPACE)) showModel = !showModel;
-
         // Display information about closest hit
         RayCollision collision = { 0 };
         collision.distance = FLT_MAX;
@@ -165,7 +161,224 @@ int main(void)
             
             // Spin the placement around a bit
             splat = MatrixMultiply(splat, MatrixRotateZ(DEG2RAD*((float)GetRandomValue(-180, 180))));
-            Matrix splatInv = MatrixInvert(splat);
+            
+            Mesh decalMesh = GenMeshDecal(model, splat, decalSize, decalOffset);
+            if (decalMesh.vertexCount > 0) {
+                int decalIndex = decalCount++;
+                decalModels[decalIndex] = LoadModelFromMesh(decalMesh);
+                decalModels[decalIndex].materials[0].maps[0] = decalMaterial.maps[0];
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+            ClearBackground(RAYWHITE);
+
+            BeginMode3D(camera);
+                // Draw the model at the origin and default scale
+                if (showModel) DrawModel(model, (Vector3){0.0f, 0.0f, 0.0f}, 1.0f, WHITE);
+                
+                // Draw the decal models
+                for (int i = 0; i < decalCount; i++) DrawModel(decalModels[i], (Vector3){0}, 1.0f, WHITE);
+
+                // If we hit the mesh, draw the box for the decal
+                if (collision.hit)
+                {
+                    Vector3 origin = Vector3Add(collision.point, Vector3Scale(collision.normal, 1.0f));
+                    Matrix splat = MatrixLookAt(collision.point, origin, (Vector3){0,1,0});
+                    placementCube.transform = MatrixInvert(splat);
+                    DrawModel(placementCube, (Vector3){0}, 1.0f, Fade(WHITE, 0.5f));
+                }
+
+                DrawGrid(10, 10.0f);
+            EndMode3D();
+
+            float yPos = 10;
+            float x0 = GetScreenWidth() - 300;
+            float x1 = x0 + 100;
+            float x2 = x1 + 100;
+            
+            DrawText("Vertices", x1, yPos, 10, LIME);
+            DrawText("Triangles", x2, yPos, 10, LIME);
+            yPos += 15;
+            
+            int vertexCount = 0;
+            int triangleCount = 0;
+            
+            for (int i = 0; i < model.meshCount; i++)
+            {
+                vertexCount += model.meshes[i].vertexCount;
+                triangleCount += model.meshes[i].triangleCount;
+            }
+            
+            DrawText("Main model", x0, yPos, 10, LIME);
+            DrawText(TextFormat("%d", vertexCount), x1, yPos, 10, LIME);
+            DrawText(TextFormat("%d", triangleCount), x2, yPos, 10, LIME);
+            yPos += 15;
+            
+            for (int i = 0; i < decalCount; i++)
+            {
+                if (i == 20) {
+                    DrawText("...", x0, yPos, 10, LIME);
+                    yPos += 15;
+                }
+                
+                if (i < 20) {
+                    DrawText(TextFormat("Decal #%d", i+1), x0, yPos, 10, LIME);
+                    DrawText(TextFormat("%d", decalModels[i].meshes[0].vertexCount), x1, yPos, 10, LIME);
+                    DrawText(TextFormat("%d", decalModels[i].meshes[0].triangleCount), x2, yPos, 10, LIME);
+                    yPos += 15;
+                }
+                
+                vertexCount += decalModels[i].meshes[0].vertexCount;
+                triangleCount += decalModels[i].meshes[0].triangleCount;
+            }
+            
+            DrawText("TOTAL", x0, yPos, 10, LIME);
+            DrawText(TextFormat("%d", vertexCount), x1, yPos, 10, LIME);
+            DrawText(TextFormat("%d", triangleCount), x2, yPos, 10, LIME);
+            yPos += 15;
+
+            DrawText("Hold RMB to move camera", 10, 430, 10, GRAY);
+            DrawText("(c) Character model and texture from kenney.nl", screenWidth - 260, screenHeight - 20, 10, GRAY);
+            
+            Rectangle rect = (Rectangle){ 10, screenHeight - 100, 100, 60 };
+            
+            if (Button(rect, showModel ? "Hide Model" : "Show Model")) {
+                showModel = !showModel;
+            }
+            
+            rect.x += rect.width + 10;
+            
+            if (Button(rect, "Clear Decals")) {
+                for (int i = 0; i < decalCount; i++)
+                {
+                    UnloadModel(decalModels[i]);
+                }
+                decalCount = 0;
+            }
+            
+
+            DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    UnloadModel(model);
+    UnloadTexture(modelTexture);
+    
+    for (int i = 0; i < decalCount; i++) {
+        UnloadModel(decalModels[i]);
+    }
+
+    UnloadTexture(decalTexture);
+    
+    // Free the data for decal generation
+    FreeDecalMeshData();
+
+    CloseWindow();              // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+// Add triangles to mesh builder (dynamic array manager)
+static void AddTriangleToMeshBuilder(MeshBuilder *mb, Vector3 vertices[3])
+{
+    // Reallocate and copy if we need to
+    if (mb->vertexCapacity <= (mb->vertexCount + 3))
+    {
+        int newVertexCapacity = (1 + (mb->vertexCapacity/256))*256;
+        Vector3 *newVertices = (Vector3 *)MemAlloc(newVertexCapacity*sizeof(Vector3));
+        
+        if (mb->vertexCapacity > 0)
+        {
+            memcpy(newVertices, mb->vertices, mb->vertexCount*sizeof(Vector3));
+            MemFree(mb->vertices);
+        }
+        
+        mb->vertices = newVertices;
+        mb->vertexCapacity = newVertexCapacity;
+    }
+    
+    // Add 3 vertices
+    int index = mb->vertexCount;
+    mb->vertexCount += 3;
+    
+    for (int i = 0; i < 3; i++) mb->vertices[index+i] = vertices[i];
+}
+
+// Free mesh builder
+static void FreeMeshBuilder(MeshBuilder *mb)
+{
+    MemFree(mb->vertices);
+    if (mb->uvs) MemFree(mb->uvs);
+    *mb = (MeshBuilder){ 0 };
+}
+
+// Build a Mesh from MeshBuilder data
+static Mesh BuildMesh(MeshBuilder *mb)
+{
+    Mesh outMesh = { 0 };
+    
+    outMesh.vertexCount = mb->vertexCount;
+    outMesh.triangleCount = mb->vertexCount/3;
+    outMesh.vertices = MemAlloc(outMesh.vertexCount*3*sizeof(float));
+    if (mb->uvs) outMesh.texcoords = MemAlloc(outMesh.vertexCount*2*sizeof(float));
+
+    for (int i = 0; i < mb->vertexCount; i++)
+    {
+        outMesh.vertices[3*i+0] = mb->vertices[i].x;
+        outMesh.vertices[3*i+1] = mb->vertices[i].y;
+        outMesh.vertices[3*i+2] = mb->vertices[i].z;
+        
+        if (mb->uvs)
+        {
+            outMesh.texcoords[2*i+0] = mb->uvs[i].x;
+            outMesh.texcoords[2*i+1] = mb->uvs[i].y;
+        }
+    }
+    
+    UploadMesh(&outMesh, false);
+    
+    return outMesh;
+}
+
+// Clip segment
+static Vector3 ClipSegment(Vector3 v0, Vector3 v1, Vector3 p, float s)
+{
+    float d0 = Vector3DotProduct(v0, p) - s;
+    float d1 = Vector3DotProduct(v1, p) - s;
+    float s0 = d0/(d0 - d1);
+
+    Vector3 position = Vector3Lerp(v0, v1, s0);
+
+    return position;
+}
+
+static Mesh GenMeshDecal(Model inputModel, Matrix projection, float decalSize, float decalOffset)
+{
+    // We're going to use these to build up our decal meshes
+    // They'll resize automatically as we go, we'll free them at the end
+    static MeshBuilder meshBuilders[2] = { 0 };
+    
+    // Ugly way of telling us to free the static MeshBuilder data
+    if (inputModel.meshCount == -1) {
+        FreeMeshBuilder(&meshBuilders[0]);
+        FreeMeshBuilder(&meshBuilders[1]);
+        return (Mesh){0};
+    }
+    
+    // We're going to need the inverse matrix
+    Matrix invProj = MatrixInvert(projection);
             
     // Reset the mesh builders
     meshBuilders[0].vertexCount = 0;
@@ -176,9 +389,9 @@ int main(void)
     int mbIndex = 0;
 
     // First pass, just get any triangle inside the bounding box (for each mesh of the model)
-            for (int meshIndex = 0; meshIndex < model.meshCount; meshIndex++)
+    for (int meshIndex = 0; meshIndex < inputModel.meshCount; meshIndex++)
     {
-                Mesh mesh = model.meshes[meshIndex];
+        Mesh mesh = inputModel.meshes[meshIndex];
         for (int tri = 0; tri < mesh.triangleCount; tri++)
         {
             Vector3 vertices[3] = { 0 };
@@ -213,8 +426,8 @@ int main(void)
             int insideCount = 0;
             for (int i = 0; i < 3; i++)
             {
-                        // To splat space
+                // To projection space
-                        Vector3 v = Vector3Transform(vertices[i], splat);
+                Vector3 v = Vector3Transform(vertices[i], projection);
                 
                 if ((fabsf(v.x) < decalSize) || (fabsf(v.y) <= decalSize) || (fabsf(v.z) <= decalSize)) insideCount++;
                 
@@ -354,185 +567,41 @@ int main(void)
             theMesh->uvs[i].x = (theMesh->vertices[i].x/decalSize + 0.5f);
             theMesh->uvs[i].y = (theMesh->vertices[i].y/decalSize + 0.5f);
             
-                    // From splat space to world space
-                    theMesh->vertices[i] = Vector3Transform(theMesh->vertices[i], splatInv);
-                    
             // Tiny nudge in the normal direction so it renders properly over the mesh
-                    theMesh->vertices[i] = Vector3Add(theMesh->vertices[i], Vector3Scale(collision.normal, decalOffset));
+            theMesh->vertices[i].z -= decalOffset;
+            
+            // From projection space to world space
+            theMesh->vertices[i] = Vector3Transform(theMesh->vertices[i], invProj);
         }
         
-                // Decal model data ready, create it and add it
+        // Decal model data ready, create the mesh and return it
-                int decalIndex = decalCount++;
+        return BuildMesh(theMesh);
-                decalModels[decalIndex] = LoadModelFromMesh(BuildMesh(theMesh));
-                decalModels[decalIndex].materials[0] = decalMaterial;
     }
-        }
+    else
-        //----------------------------------------------------------------------------------
-
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-            ClearBackground(RAYWHITE);
-
-            BeginMode3D(camera);
-                // Draw the model at the origin and default scale
-                if (showModel) DrawModel(model, (Vector3){0.0f, 0.0f, 0.0f}, 1.0f, WHITE);
-                
-                // Draw the decal models
-                for (int i = 0; i < decalCount; i++) DrawModel(decalModels[i], (Vector3){0}, 1.0f, WHITE);
-
-                // If we hit the mesh, draw the box for the decal 
-                if (collision.hit)
     {
-                    Vector3 origin = Vector3Add(collision.point, Vector3Scale(collision.normal, 1.0f));
+        // Return a blank mesh as there's nothing to add
-                    Matrix splat = MatrixLookAt(collision.point, origin, (Vector3){0,1,0});
+        return (Mesh){ 0 };
-                    placementCube.transform = MatrixInvert(splat);
-                    DrawModel(placementCube, (Vector3){0}, 1.0f, Fade(WHITE, 0.5f));
     }
-
-                DrawGrid(10, 10.0f);
-            EndMode3D();
-
-            float yPos = 10;
-            float x0 = GetScreenWidth() - 300;
-            float x1 = x0 + 100;
-            float x2 = x1 + 100;
-            
-            DrawText("Vertices", x1, yPos, 10, LIME);
-            DrawText("Triangles", x2, yPos, 10, LIME);
-            yPos += 15;
-            
-            int vertexCount = 0;
-            int triangleCount = 0;
-            
-            for (int i = 0; i < model.meshCount; i++)
-            {
-                vertexCount += model.meshes[i].vertexCount;
-                triangleCount += model.meshes[i].triangleCount;
-            }
-            
-            DrawText("Main model", x0, yPos, 10, LIME);
-            DrawText(TextFormat("%d", vertexCount), x1, yPos, 10, LIME);
-            DrawText(TextFormat("%d", triangleCount), x2, yPos, 10, LIME);
-            yPos += 15;
-            
-            for (int i = 0; i < decalCount; i++)
-            {
-                DrawText(TextFormat("Decal #%d", i+1), x0, yPos, 10, LIME);
-                DrawText(TextFormat("%d", decalModels[i].meshes[0].vertexCount), x1, yPos, 10, LIME);
-                DrawText(TextFormat("%d", decalModels[i].meshes[0].triangleCount), x2, yPos, 10, LIME);
-                
-                vertexCount += decalModels[i].meshes[0].vertexCount;
-                triangleCount += decalModels[i].meshes[0].triangleCount;
-                yPos += 15;
-            }
-            
-            DrawText("TOTAL", x0, yPos, 10, LIME);
-            DrawText(TextFormat("%d", vertexCount), x1, yPos, 10, LIME);
-            DrawText(TextFormat("%d", triangleCount), x2, yPos, 10, LIME);
-            yPos += 15;
-
-            DrawText("Hold RMB to move camera", 10, 430, 10, GRAY);
-            DrawText("(c) Character model and texture from kenney.nl", screenWidth - 260, screenHeight - 20, 10, GRAY);
-
-            DrawFPS(10, 10);
-
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    UnloadModel(model);
-    UnloadTexture(modelTexture);
-    
-    // TODO: WARNING: This line crashes program on closing
-    //for (int i = 0; i < decalCount; i++) UnloadModel(decalModels[i]);
-
-    UnloadTexture(decalTexture);
-    
-    FreeMeshBuilder(&meshBuilders[0]);
-    FreeMeshBuilder(&meshBuilders[1]);
-
-    CloseWindow();              // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
 }
 
-//----------------------------------------------------------------------------------
+static bool Button(Rectangle rec, char *label)
-// Module Functions Definition
-//----------------------------------------------------------------------------------
-// Add triangles to mesh builder (dynamic array manager)
-static void AddTriangleToMeshBuilder(MeshBuilder *mb, Vector3 vertices[3])
 {
-    // Reallocate and copy if we need to
+    Color bgColor = GRAY;
-    if (mb->vertexCapacity <= (mb->vertexCount + 3))
+    bool pressed = false;
-    {
+    if (CheckCollisionPointRec(GetMousePosition(), rec)) {
-        int newVertexCapacity = (1 + (mb->vertexCapacity/256))*256;
+        bgColor = LIGHTGRAY;
-        Vector3 *newVertices = (Vector3 *)MemAlloc(newVertexCapacity*sizeof(Vector3));
+        if (IsMouseButtonPressed(MOUSE_BUTTON_LEFT)) {
-        
+            pressed = true;
-        if (mb->vertexCapacity > 0)
-        {
-            memcpy(newVertices, mb->vertices, mb->vertexCount*sizeof(Vector3));
-            MemFree(mb->vertices);
-        }
-        
-        mb->vertices = newVertices;
-        mb->vertexCapacity = newVertexCapacity;
-    }
-    
-    // Add 3 vertices
-    int index = mb->vertexCount;
-    mb->vertexCount += 3;
-    
-    for (int i = 0; i < 3; i++) mb->vertices[index+i] = vertices[i];
-}
-
-// Free mesh builder
-static void FreeMeshBuilder(MeshBuilder *mb)
-{
-    MemFree(mb->vertices);
-    if (mb->uvs) MemFree(mb->uvs);
-    *mb = (MeshBuilder){ 0 };
-}
-
-// Build a Mesh from MeshBuilder data
-static Mesh BuildMesh(MeshBuilder *mb)
-{
-    Mesh outMesh = { 0 };
-    
-    outMesh.vertexCount = mb->vertexCount;
-    outMesh.triangleCount = mb->vertexCount/3;
-    outMesh.vertices = MemAlloc(outMesh.vertexCount*3*sizeof(float));
-    if (mb->uvs) outMesh.texcoords = MemAlloc(outMesh.vertexCount*2*sizeof(float));
-
-    for (int i = 0; i < mb->vertexCount; i++)
-    {
-        outMesh.vertices[3*i+0] = mb->vertices[i].x;
-        outMesh.vertices[3*i+1] = mb->vertices[i].y;
-        outMesh.vertices[3*i+2] = mb->vertices[i].z;
-        
-        if (mb->uvs)
-        {
-            outMesh.texcoords[2*i+0] = mb->uvs[i].x;
-            outMesh.texcoords[2*i+1] = mb->uvs[i].y;
         }
     }
     
-    UploadMesh(&outMesh, false);
+    DrawRectangleRec(rec, bgColor);
+    DrawRectangleLinesEx(rec, 2.0f, DARKGRAY);
     
-    return outMesh;
+    float fontSize = 10.0f;
-}
+    float textWidth = MeasureText(label, fontSize);
-
+    
-// Clip segment
+    DrawText(label, (int)(rec.x + rec.width*0.5f - textWidth*0.5f), (int)(rec.y + rec.height*0.5f - fontSize*0.5f), fontSize, DARKGRAY);
-static Vector3 ClipSegment(Vector3 v0, Vector3 v1, Vector3 p, float s)
+    
-{
+    return pressed;
-    float d0 = Vector3DotProduct(v0, p) - s;
-    float d1 = Vector3DotProduct(v1, p) - s;
-    float s0 = d0/(d0 - d1);
-
-    Vector3 position = Vector3Lerp(v0, v1, s0);
-
-    return position;
 }