canvasframework 0.4.9 → 0.4.11

package/core/CanvasFramework.js

@@ -155,11 +155,53 @@ class CanvasFramework {
     constructor(canvasId, options = {}) {
         // ✅ AJOUTER: Démarrer le chronomètre
         const startTime = performance.now();
+        
+        // ✅ OPTIMISATION OPTION 5: Contexte Canvas optimisé
         this.canvas = document.getElementById(canvasId);
-        this.ctx = this.canvas.getContext('2d');
+        this.ctx = this.canvas.getContext('2d', {
+            alpha: false, // ✅ Gain de 30% de performance
+            desynchronized: true, // ✅ Bypass la queue du navigateur
+            willReadFrequently: false
+        });
+        
+		this.backgroundColor = options.backgroundColor || '#f5f5f5'; // Blanc par défaut
+		
         this.width = window.innerWidth;
         this.height = window.innerHeight;
         this.dpr = window.devicePixelRatio || 1;
+        
+        // ✅ OPTIMISATION OPTION 2: Configuration des optimisations
+        this.optimizations = {
+            enabled: options.optimizations !== false, // Activé par défaut
+            useDoubleBuffering: true,
+            useCaching: true,
+            useBatchDrawing: true,
+            useSpatialPartitioning: false, // Désactivé par défaut (à activer si beaucoup de composants)
+            useImageDataOptimization: true
+        };
+        
+        // ✅ OPTIMISATION OPTION 2: Cache pour éviter les changements d'état inutiles
+        this._stateCache = {
+            fillStyle: null,
+            strokeStyle: null,
+            font: null,
+            textAlign: null,
+            textBaseline: null,
+            lineWidth: null,
+            globalAlpha: 1
+        };
+        
+        // ✅ OPTIMISATION OPTION 2: Cache des images/textes
+        this.imageCache = new Map();
+        this.textCache = new Map();
+        
+        // ✅ OPTIMISATION OPTION 2: Double buffering
+        this._doubleBuffer = null;
+        this._bufferCtx = null;
+        if (this.optimizations.useDoubleBuffering) {
+            this._initDoubleBuffer();
+        }
+        
         this.splashOptions = {
             enabled: options.splash?.enabled === true, // false par défaut
             duration: options.splash?.duration || 700,
@@ -178,6 +220,7 @@ class CanvasFramework {
             logoWidth: options.splash?.logoWidth || 100,
             logoHeight: options.splash?.logoHeight || 100
         };
+        
         // ✅ MODIFIER : Vérifier si le splash est activé
         if (this.splashOptions.enabled) {
             this.showSplashScreen();
@@ -187,7 +230,6 @@ class CanvasFramework {
 
         this.platform = this.detectPlatform();
 
-
         // État actuel + préférence
         this.themeMode = options.themeMode || 'system'; // 'light', 'dark', 'system'
         this.userThemeOverride = null; // null = suit system, sinon 'light' ou 'dark'
@@ -213,7 +255,7 @@ class CanvasFramework {
         // NOUVELLE OPTION: choisir entre Canvas 2D et WebGL
         this.useWebGL = options.useWebGL !== false; // true par défaut
         // Initialiser le contexte approprié
-        if (this.useWebGL) {
+        /*if (this.useWebGL) {
             try {
                 this.ctx = new WebGLCanvasAdapter(this.canvas);
             } catch (e) {
@@ -222,7 +264,8 @@ class CanvasFramework {
             }
         } else {
             this.ctx = this.canvas.getContext('2d');
-        }
+        }*/
+        
         // Calcule FPS
         this.fps = 0;
         this._frames = 0;
@@ -264,7 +307,7 @@ class CanvasFramework {
 
         // Optimisation
         this.dirtyComponents = new Set();
-        this.optimizationEnabled = false;
+        this.optimizationEnabled = this.optimizations.enabled;
 
         // AJOUTER CETTE LIGNE
         this.animator = new AnimationEngine();
@@ -289,10 +332,13 @@ class CanvasFramework {
         };
 
         this.setupCanvas();
+        
+        // ✅ OPTIMISATION OPTION 5: Désactiver l'antialiasing pour meilleures performances
+        this._disableImageSmoothing();
+        
         this.setupEventListeners();
         this.setupHistoryListener();
 
-
         this.startRenderLoop();
 
         this.devTools = new DevTools(this);
@@ -335,6 +381,340 @@ class CanvasFramework {
         // ✅ AJOUTER: Marquer le premier rendu
         this._firstRenderDone = false;
         this._startupStartTime = startTime;
+        
+        // ✅ OPTIMISATION OPTION 5: Partition spatiale pour le culling (optionnel)
+        if (this.optimizations.useSpatialPartitioning) {
+            this._initSpatialPartitioning();
+        }
+    }
+	
+	/**
+     * Initialise le double buffering pour éviter le flickering
+     * @private
+     */
+    _initDoubleBuffer() {
+        this._doubleBuffer = document.createElement('canvas');
+        this._bufferCtx = this._doubleBuffer.getContext('2d', {
+            alpha: false,
+            desynchronized: true
+        });
+        this._doubleBuffer.width = this.width * this.dpr;
+        this._doubleBuffer.height = this.height * this.dpr;
+        this._doubleBuffer.style.width = this.width + 'px';
+        this._doubleBuffer.style.height = this.height + 'px';
+        this._bufferCtx.scale(this.dpr, this.dpr);
+        this._disableImageSmoothing(this._bufferCtx);
+    }
+    
+    /**
+     * Désactive l'antialiasing pour meilleures performances
+     * @private
+     * @param {CanvasRenderingContext2D} [ctx=this.ctx] - Contexte à configurer
+     */
+    _disableImageSmoothing(ctx = this.ctx) {
+        ctx.imageSmoothingEnabled = false;
+        ctx.msImageSmoothingEnabled = false;
+        ctx.webkitImageSmoothingEnabled = false;
+        ctx.mozImageSmoothingEnabled = false;
+    }
+    
+    /**
+     * Initialise le spatial partitioning pour le viewport culling
+     * @private
+     */
+    _initSpatialPartitioning() {
+        // Simple grid spatial partitioning
+        this._spatialGrid = {
+            cellSize: 100,
+            grid: new Map(),
+            update: (components) => {
+                this._spatialGrid.grid.clear();
+                components.forEach(comp => {
+                    if (!comp.visible) return;
+                    
+                    const gridX = Math.floor(comp.x / this._spatialGrid.cellSize);
+                    const gridY = Math.floor(comp.y / this._spatialGrid.cellSize);
+                    const key = `${gridX},${gridY}`;
+                    
+                    if (!this._spatialGrid.grid.has(key)) {
+                        this._spatialGrid.grid.set(key, []);
+                    }
+                    this._spatialGrid.grid.get(key).push(comp);
+                });
+            },
+            getVisible: (viewportY) => {
+                const visible = [];
+                const startY = viewportY - 200; // Marge de 200px
+                const endY = viewportY + this.height + 200;
+                
+                this._spatialGrid.grid.forEach((comps, key) => {
+                    comps.forEach(comp => {
+                        const compBottom = comp.y + comp.height;
+                        if (compBottom >= startY && comp.y <= endY) {
+                            visible.push(comp);
+                        }
+                    });
+                });
+                return visible;
+            }
+        };
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 2: Rendu optimisé de rectangles
+     * Évite les changements d'état inutiles
+     * @param {number} x - Position X
+     * @param {number} y - Position Y
+     * @param {number} w - Largeur
+     * @param {number} h - Hauteur
+     * @param {string} color - Couleur de remplissage
+     */
+    fillRectOptimized(x, y, w, h, color) {
+        // Éviter les changements d'état inutiles
+        if (this._stateCache.fillStyle !== color) {
+            this.ctx.fillStyle = color;
+            this._stateCache.fillStyle = color;
+        }
+        this.ctx.fillRect(x, y, w, h);
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 2: Texte avec cache
+     * Cache le rendu du texte pour éviter de le redessiner à chaque frame
+     * @param {string} text - Texte à afficher
+     * @param {number} x - Position X
+     * @param {number} y - Position Y
+     * @param {string} font - Police CSS
+     * @param {string} color - Couleur du texte
+     */
+    fillTextCached(text, x, y, font, color) {
+        const key = `${text}_${font}_${color}`;
+        
+        if (!this.textCache.has(key)) {
+            // Rendu dans un canvas temporaire
+            const temp = document.createElement('canvas');
+            const tempCtx = temp.getContext('2d', { alpha: false });
+            tempCtx.font = font;
+            
+            const metrics = tempCtx.measureText(text);
+            temp.width = Math.ceil(metrics.width);
+            temp.height = Math.ceil(parseInt(font) * 1.2);
+            
+            tempCtx.font = font;
+            tempCtx.fillStyle = color;
+            tempCtx.textBaseline = 'top';
+            tempCtx.fillText(text, 0, 0);
+            
+            this.textCache.set(key, {
+                canvas: temp,
+                width: temp.width,
+                height: temp.height,
+                baseline: parseInt(font)
+            });
+        }
+        
+        const cached = this.textCache.get(key);
+        this.ctx.drawImage(cached.canvas, x, y - cached.baseline);
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 5: Rendu batché pour plusieurs rectangles
+     * Regroupe les rectangles par couleur pour réduire les appels draw
+     * @param {Array} rects - Tableau d'objets {x, y, width, height, color}
+     */
+    batchRect(rects) {
+        if (!rects || rects.length === 0) return;
+        
+        // Regrouper par couleur
+        const batches = new Map();
+        
+        rects.forEach(rect => {
+            if (!batches.has(rect.color)) {
+                batches.set(rect.color, []);
+            }
+            batches.get(rect.color).push(rect);
+        });
+        
+        // Dessiner par batch
+        batches.forEach((batchRects, color) => {
+            this.ctx.fillStyle = color;
+            
+            // Utiliser un seul path pour tous les rectangles de même couleur
+            this.ctx.beginPath();
+            batchRects.forEach(rect => {
+                this.ctx.rect(rect.x, rect.y, rect.width, rect.height);
+            });
+            this.ctx.fill();
+        });
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 5: Utiliser ImageData pour les mises à jour fréquentes
+     * @param {number} x - Position X
+     * @param {number} y - Position Y
+     * @param {number} width - Largeur
+     * @param {number} height - Hauteur
+     * @param {Function} drawFn - Fonction pour manipuler les pixels
+     */
+    updateRegion(x, y, width, height, drawFn) {
+        const imageData = this.ctx.getImageData(x, y, width, height);
+        const data = imageData.data;
+        
+        // Manipuler directement les pixels
+        drawFn(data, width, height);
+        
+        this.ctx.putImageData(imageData, x, y);
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 2: Flush du buffer pour le double buffering
+     */
+    flush() {
+        if (this.optimizations.useDoubleBuffering && this._bufferCtx) {
+            // Dessiner le buffer sur le canvas réel
+            this.ctx.drawImage(this._doubleBuffer, 0, 0);
+            // Effacer le buffer pour le prochain frame
+            this._bufferCtx.clearRect(0, 0, this.width, this.height);
+        }
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 5: Rendu optimisé avec viewport culling
+     * @private
+     */
+    _renderOptimized() {
+        const ctx = this.optimizations.useDoubleBuffering ? this._bufferCtx : this.ctx;
+        
+        if (!ctx) return;
+        
+        // Clear le canvas
+        ctx.clearRect(0, 0, this.width, this.height);
+        
+        // Séparer les composants fixes et scrollables
+        const scrollableComponents = [];
+        const fixedComponents = [];
+
+        for (let comp of this.components) {
+            if (this.isFixedComponent(comp)) {
+                fixedComponents.push(comp);
+            } else {
+                scrollableComponents.push(comp);
+            }
+        }
+
+        // Rendu des composants scrollables avec viewport culling optimisé
+        ctx.save();
+        ctx.translate(0, this.scrollOffset);
+        
+        // ✅ OPTIMISATION: Utiliser le spatial partitioning si activé
+        if (this.optimizations.useSpatialPartitioning && this._spatialGrid) {
+            const visibleComps = this._spatialGrid.getVisible(-this.scrollOffset);
+            for (let comp of visibleComps) {
+                if (comp.visible) {
+                    comp.draw(ctx);
+                }
+            }
+        } else {
+            // Rendu standard avec culling simple
+            for (let comp of scrollableComponents) {
+                if (comp.visible) {
+                    const screenY = comp.y + this.scrollOffset;
+                    const isInViewport = screenY + comp.height >= -100 && screenY <= this.height + 100;
+
+                    if (isInViewport) {
+                        comp.draw(ctx);
+                    }
+                }
+            }
+        }
+        
+        ctx.restore();
+
+        // Rendu des composants fixes
+        for (let comp of fixedComponents) {
+            if (comp.visible) {
+                comp.draw(ctx);
+            }
+        }
+        
+        // Flush si on utilise le double buffering
+        if (this.optimizations.useDoubleBuffering) {
+            this.flush();
+        }
+    }
+    
+    /**
+     * ✅ OPTIMISATION OPTION 2: Rendu partiel (seulement les composants sales)
+     * @private
+     */
+    _renderDirtyComponents() {
+        const ctx = this.optimizations.useDoubleBuffering ? this._bufferCtx : this.ctx;
+        
+        if (!ctx) return;
+        
+        this.dirtyComponents.forEach(comp => {
+            if (comp.visible) {
+                const isFixed = this.isFixedComponent(comp);
+                const y = isFixed ? comp.y : comp.y + this.scrollOffset;
+                
+                // Nettoyer la zone avant de redessiner
+                ctx.clearRect(
+                    comp.x - 1, 
+                    y - 1, 
+                    comp.width + 2, 
+                    comp.height + 2
+                );
+                
+                ctx.save();
+                if (!isFixed) ctx.translate(0, this.scrollOffset);
+                comp.draw(ctx);
+                ctx.restore();
+                
+                if (comp.markClean) comp.markClean();
+            }
+        });
+        
+        this.dirtyComponents.clear();
+        
+        // Flush si on utilise le double buffering
+        if (this.optimizations.useDoubleBuffering) {
+            this.flush();
+        }
+    }
+    
+    /**
+     * Active/désactive une optimisation spécifique
+     * @param {string} optimization - Nom de l'optimisation
+     * @param {boolean} enabled - true pour activer, false pour désactiver
+     */
+    setOptimization(optimization, enabled) {
+        if (this.optimizations.hasOwnProperty(optimization)) {
+            this.optimizations[optimization] = enabled;
+            
+            switch(optimization) {
+                case 'useDoubleBuffering':
+                    if (enabled && !this._bufferCtx) {
+                        this._initDoubleBuffer();
+                    }
+                    break;
+                case 'useSpatialPartitioning':
+                    if (enabled && !this._spatialGrid) {
+                        this._initSpatialPartitioning();
+                    }
+                    break;
+            }
+            
+            // Marquer tous les composants comme sales pour forcer un redessin complet
+            this.components.forEach(comp => this.markComponentDirty(comp));
+        }
+    }
+    
+    /**
+     * Obtient l'état des optimisations
+     * @returns {Object} État des optimisations
+     */
+    getOptimizations() {
+        return { ...this.optimizations };
     }
 
     /**
@@ -478,7 +858,17 @@ class CanvasFramework {
                 requestAnimationFrame(fade);
             } else {
                 this._splashFinished = true;
-                this.ctx.clearRect(0, 0, this.width, this.height);
+				// ✅ AJOUTER : Réinitialiser complètement le contexte
+			    this.ctx.clearRect(0, 0, this.width, this.height);
+			    this.ctx.globalAlpha = 1;
+			    this.ctx.textAlign = 'start'; // ← IMPORTANT
+			    this.ctx.textBaseline = 'alphabetic'; // ← IMPORTANT
+			    this.ctx.font = '10px sans-serif'; // Valeur par défaut
+			    this.ctx.fillStyle = '#000000';
+			    this.ctx.strokeStyle = '#000000';
+			    this.ctx.lineWidth = 1;
+			    this.ctx.lineCap = 'butt';
+			    this.ctx.lineJoin = 'miter';
             }
         };
 
@@ -855,13 +1245,16 @@ class CanvasFramework {
         this.canvas.style.width = this.width + 'px';
         this.canvas.style.height = this.height + 'px';
 
+		// ✅ AJOUTER: Appliquer le background au style CSS
+		this.canvas.style.backgroundColor = this.backgroundColor;
         // Échelle uniquement pour Canvas 2D
-        if (!this.useWebGL) {
+		this.ctx.scale(this.dpr, this.dpr);
+        /*if (!this.useWebGL) {
             this.ctx.scale(this.dpr, this.dpr);
         } else {
             // WebGL gère le DPR automatiquement via la matrice de projection
             this.ctx.updateProjectionMatrix();
-        }
+        }*/
     }
 
     setupEventListeners() {
@@ -1573,8 +1966,25 @@ class CanvasFramework {
       }
       return Math.max(0, maxY - this.height + 50);
     }*/
-
-    handleResize() {
+	
+	handleResize() {
+    	if (this.resizeTimeout) clearTimeout(this.resizeTimeout);
+    
+    	this.resizeTimeout = setTimeout(() => {
+        	this.width = window.innerWidth;
+        	this.height = window.innerHeight;
+        	this.setupCanvas(); // ← Fait déjà tout le boulot
+        
+        	for (const comp of this.components) {
+            	if (comp._resize) {
+                	comp._resize(this.width, this.height);
+            	}
+        	}
+        	this._maxScrollDirty = true;
+    	}, 150);
+	}
+
+    /*handleResize() {
         if (this.resizeTimeout) clearTimeout(this.resizeTimeout); // ✅ AJOUTER
 
         this.resizeTimeout = setTimeout(() => { // ✅ AJOUTER
@@ -1591,7 +2001,7 @@ class CanvasFramework {
                 this._maxScrollDirty = true; // ✅ AJOUTER
             }
         }, 150); // ✅ AJOUTER (throttle 150ms)
-    }
+    }*/
 
     add(component) {
         this.components.push(component);
@@ -1780,111 +2190,116 @@ class CanvasFramework {
     }
 
     startRenderLoop() {
-        const render = () => {
-            if (!this._splashFinished) {
-                requestAnimationFrame(render);
-                return;
-            }
-            // 1️⃣ Scroll inertia
-            if (Math.abs(this.scrollVelocity) > 0.1 && !this.isDragging) {
-                this.scrollOffset += this.scrollVelocity;
-                this.scrollOffset = Math.max(Math.min(this.scrollOffset, 0), -this.getMaxScroll());
-                this.scrollVelocity *= this.scrollFriction;
-            } else {
-                this.scrollVelocity = 0;
-            }
-
-            // 2️⃣ Clear canvas
-            this.ctx.clearRect(0, 0, this.width, this.height);
-
-            // 3️⃣ Transition handling
-            if (this.transitionState.isTransitioning) {
-                this.updateTransition();
-            } else if (this.optimizationEnabled && this.dirtyComponents.size > 0) {
-                // Dirty components redraw
-                for (let comp of this.dirtyComponents) {
-                    if (comp.visible) {
-                        const isFixed = this.isFixedComponent(comp);
-                        const y = isFixed ? comp.y : comp.y + this.scrollOffset;
-
-                        this.ctx.clearRect(comp.x - 2, y - 2, comp.width + 4, comp.height + 4);
-
-                        this.ctx.save();
-                        if (!isFixed) this.ctx.translate(0, this.scrollOffset);
-                        comp.draw(this.ctx);
-                        this.ctx.restore();
-
-                        // Overflow indicator style Flutter
-                        const overflow = comp.getOverflow?.();
-                        if (comp.markClean) comp.markClean();
-                    }
-                }
-                this.dirtyComponents.clear();
-            } else {
-                // Full redraw
-                const scrollableComponents = [];
-                const fixedComponents = [];
-
-                for (let comp of this.components) {
-                    if (this.isFixedComponent(comp)) fixedComponents.push(comp);
-                    else scrollableComponents.push(comp);
-                }
-
-                // Scrollable
-                this.ctx.save();
-                this.ctx.translate(0, this.scrollOffset);
-                for (let comp of scrollableComponents) {
-                    if (comp.visible) {
-                        // ✅ Viewport culling : ne dessiner que ce qui est visible
-                        const screenY = comp.y + this.scrollOffset;
-                        const isInViewport = screenY + comp.height >= -100 && screenY <= this.height + 100;
-
-                        if (isInViewport) {
-                            comp.draw(this.ctx);
-                        }
-                    }
-                }
-                this.ctx.restore();
-
-                // Fixed
-                for (let comp of fixedComponents) {
-                    if (comp.visible) {
-                        comp.draw(this.ctx);
-                    }
-                }
-            }
-
-            // 4️⃣ FPS
-            this._frames++;
-            const now = performance.now();
-            if (now - this._lastFpsTime >= 1000) {
-                this.fps = this._frames;
-                this._frames = 0;
-                this._lastFpsTime = now;
-            }
-
-            if (this.showFps) {
-                this.ctx.save();
-                this.ctx.fillStyle = 'lime';
-                this.ctx.font = '16px monospace';
-                this.ctx.fillText(`FPS: ${this.fps}`, 10, 20);
-                this.ctx.restore();
-            }
-
-            if (this.debbug) {
-                this.drawOverflowIndicators();
-            }
-
-            // ✅ AJOUTER: Marquer le premier rendu
-            if (!this._firstRenderDone && this.components.length > 0) {
-                this._markFirstRender();
-            }
-
-            requestAnimationFrame(render);
-        };
-
-        render();
-    }
+		const render = () => {
+			if (!this._splashFinished) {
+				requestAnimationFrame(render);
+				return;
+			}
+			
+			// 1️⃣ Scroll inertia
+			if (Math.abs(this.scrollVelocity) > 0.1 && !this.isDragging) {
+				this.scrollOffset += this.scrollVelocity;
+				this.scrollOffset = Math.max(Math.min(this.scrollOffset, 0), -this.getMaxScroll());
+				this.scrollVelocity *= this.scrollFriction;
+			} else {
+				this.scrollVelocity = 0;
+			}
+
+			// 2️⃣ Clear canvas AVEC BACKGROUND
+			// Remplacer clearRect par fillRect avec ta couleur
+			this.ctx.fillStyle = this.backgroundColor || '#ffffff';
+			this.ctx.fillRect(0, 0, this.width, this.height);
+
+			// 3️⃣ Transition handling
+			if (this.transitionState.isTransitioning) {
+				this.updateTransition();
+			} else if (this.optimizationEnabled && this.dirtyComponents.size > 0) {
+				// Dirty components redraw
+				for (let comp of this.dirtyComponents) {
+					if (comp.visible) {
+						const isFixed = this.isFixedComponent(comp);
+						const y = isFixed ? comp.y : comp.y + this.scrollOffset;
+
+						// Pour les composants sales, nettoyer la zone AVEC le background
+						this.ctx.fillStyle = this.backgroundColor || '#ffffff';
+						this.ctx.fillRect(comp.x - 2, y - 2, comp.width + 4, comp.height + 4);
+
+						this.ctx.save();
+						if (!isFixed) this.ctx.translate(0, this.scrollOffset);
+						comp.draw(this.ctx);
+						this.ctx.restore();
+
+						// Overflow indicator style Flutter
+						const overflow = comp.getOverflow?.();
+						if (comp.markClean) comp.markClean();
+					}
+				}
+				this.dirtyComponents.clear();
+			} else {
+				// Full redraw
+				const scrollableComponents = [];
+				const fixedComponents = [];
+
+				for (let comp of this.components) {
+					if (this.isFixedComponent(comp)) fixedComponents.push(comp);
+					else scrollableComponents.push(comp);
+				}
+
+				// Scrollable
+				this.ctx.save();
+				this.ctx.translate(0, this.scrollOffset);
+				for (let comp of scrollableComponents) {
+					if (comp.visible) {
+						// ✅ Viewport culling : ne dessiner que ce qui est visible
+						const screenY = comp.y + this.scrollOffset;
+						const isInViewport = screenY + comp.height >= -100 && screenY <= this.height + 100;
+
+						if (isInViewport) {
+							comp.draw(this.ctx);
+						}
+					}
+				}
+				this.ctx.restore();
+
+				// Fixed
+				for (let comp of fixedComponents) {
+					if (comp.visible) {
+						comp.draw(this.ctx);
+					}
+				}
+			}
+
+			// 4️⃣ FPS
+			this._frames++;
+			const now = performance.now();
+			if (now - this._lastFpsTime >= 1000) {
+				this.fps = this._frames;
+				this._frames = 0;
+				this._lastFpsTime = now;
+			}
+
+			if (this.showFps) {
+				this.ctx.save();
+				this.ctx.fillStyle = 'lime';
+				this.ctx.font = '16px monospace';
+				this.ctx.fillText(`FPS: ${this.fps}`, 10, 20);
+				this.ctx.restore();
+			}
+
+			if (this.debbug) {
+				this.drawOverflowIndicators();
+			}
+
+			// ✅ AJOUTER: Marquer le premier rendu
+			if (!this._firstRenderDone && this.components.length > 0) {
+				this._markFirstRender();
+			}
+
+			requestAnimationFrame(render);
+		};
+
+		render();
+	}
 
     // ✅ AJOUTER: Afficher les métriques à l'écran
     displayMetrics() {