Comment puis-je dessiner efficacement plusieurs pixels sur un canevas?

Question

Je fais mon premier jeu en utilisant Java sur Android. J'ai besoin de dessiner beaucoup de pixels qui ensemble devraient créer une ligne. Ma première approche consistait à créer un grand nombre de booléens, à créer une boucle et à dessiner un pixel lorsque le booléen associé était vrai.

Ce n'était pas une bonne idée bien sûr (le tableau fait environ 200x300). Maintenant, je me souviens seulement de la position du premier pixel de la ligne, et chaque pixel suivant doit se souvenir de son suiveur. Ca marche plutôt bien, mais quand la ligne s'allonge (mais pas encore très longtemps), l'efficacité est mauvaise (< 20 fps après 4000 frames).

C'est la fonction que j'utilise pour dessiner une ligne (une seule pour l'instant). Quelqu'un peut-il m'aider à améliorer son efficacité?

public void drawLine(Canvas canvas, int beginx, int beginy) { 
    Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG); 
    paint.setColor(Color.RED); 
    paint.setStrokeWidth(3); 

    int x = beginx; 
    int y = beginy; 
    while(C.mGrid[x][y].nx != -1) { 
     //canvas.drawLine(x, y, C.mGrid[x][y].nx, C.mGrid[x][y].ny, paint); 
     canvas.drawPoint(x, y, paint); 
     Grid temp = C.mGrid[x][y]; 
     if ((C.mGrid[x][y].nx == x) && (C.mGrid[x][y].ny == y)) break; 
     x = temp.nx; 
     y = temp.ny; 
    } 
} 

et Grid.java:

package com.qwak.achtung; 

public float x = 0,y = 0; 
public int px = -1, py = -1, nx = -1, ny = -1; 

public Grid(float x, float y) { 
    this.x = x; 
    this.y = y; 
} 

public void set(int px, int py, int nx, int ny) { 
    this.px = px; 
    this.py = py; 
    this.nx = nx; 
    this.ny = ny; 
} 

public void setp(int px, int py) { 
    this.px = px; 
    this.py = py; 
} 

public void setn(int nx, int ny) { 
    this.nx = nx; 
    this.ny = ny; 
} 

PS: Il semble fonctionner mieux comme ça http://c.wrzuta.pl/wi10559/11f7d10b00110e504e25ebd3/0/andek 14 est fps (sur mon téléphone (Samsung Spica) - 40 mais après un certain temps, il diminue à 20 et encore moins) et 983 est le nombre d'images du tout.

Answer 1

Il existe une méthode drawLine dans l'objet canvas.

Utilisez l'exemple ici: How to draw a line in android

canvas.drawLine(0, 0, 20, 20, paint); 

Si vous voulez dessiner une courbe. Trouvez la fonction de la courbe. Une parabole par exemple est x = y^2. Vous pouvez obtenir des points de la courbe: 1 = 1, 2 = 4, 3 = 9, 4 = 16 ... etc Si votre dessin pixel par pixel, vous pouvez brancher votre x et obtenir votre y et dessiner.

Peinture de peinture = nouvelle peinture (Paint.ANTI_ALIAS_FLAG); paint.setColor (Color.RED); paint.setStrokeWidth (3);

for(int i = beginx; i < CanvasWidth; i++) 
{ 
    int x = i; 
    int y = i * i; //x=y^2 
    canvas.drawPoint(x, y, paint); 
} 

Pour conserver un enregistrement de points qui ont été visités, vous pouvez effectuer les opérations suivantes:

class Point 
{ 
    int x; 
    int y; 
} 


List<Point> points = new List<Point>(); 

onMove(int newX, int newY) 
{ 
    Point p = new Point(); 
    p.x = newX; 
    p.y = newY; 

    points.add(p); 
} 


onDraw() 
{ 
    for(Point p : points) 
    { 
     canvas.drawPoint(p.x, p.y, paint); 
    } 
} 

Answer 2

Vous voulez regarder dans l'algorithme de Bresenham. Un algorithme de Bresenham est une méthode pour dessiner ou pixelliser une ligne. C'est un peu différent de la subdivision d'une grille dans un certain angle, par exemple une courbe de morton. C'est un peu comme calculer le produit scalaire pour chaque angle comme rappeler ici Traversing a 2D array in an angle.