Ai-je implémenté cela correctement?

Question

Je suis en train de mettre en œuvre l'épaisseur de la ligne comme indiqué ici:

start = line start = vector(x1, y1) 
end = line end = vector(x2, y2) 
dir = line direction = end - start = vector(x2-x1, y2-y1) 
ndir = normalized direction = dir*1.0/length(dir) 
perp = perpendicular to direction = vector(dir.x, -dir.y) 
nperp = normalized perpendicular = perp*1.0/length(perp) 

perpoffset = nperp*w*0.5 
diroffset = ndir*w*0.5 


p0, p1, p2, p3 = polygon points: 
p0 = start + perpoffset - diroffset 
p1 = start - perpoffset - diroffset 
p2 = end + perpoffset + diroffset 
p3 = end - perpoffset + diroffset 

J'ai mis en œuvre ce comme ceci:

void OGLENGINEFUNCTIONS::GenerateLinePoly(const std::vector<std::vector<GLdouble>> &input, std::vector<GLfloat> &output, int width) 
{ 
    output.clear(); 
    float temp; 
    float dirlen; 
    float perplen; 
    POINTFLOAT start; 
    POINTFLOAT end; 
    POINTFLOAT dir; 
    POINTFLOAT ndir; 
    POINTFLOAT perp; 
    POINTFLOAT nperp; 

    POINTFLOAT perpoffset; 
    POINTFLOAT diroffset; 

    POINTFLOAT p0, p1, p2, p3; 

    for(int i = 0; i < input.size() - 1; ++i) 
    { 
     start.x = input[i][0]; 
     start.y = input[i][1]; 

     end.x = input[i + 1][0]; 
     end.y = input[i + 1][1]; 

     dir.x = end.x - start.x; 
     dir.y = end.y - start.y; 

     dirlen = sqrt((dir.x * dir.x) + (dir.y * dir.y)); 

     ndir.x = dir.x * (1.0/dirlen); 
     ndir.y = dir.y * (1.0/dirlen); 

     perp.x = dir.x; 
     perp.y = -dir.y; 

     perplen = sqrt((perp.x * perp.x) + (perp.y * perp.y)); 

     nperp.x = perp.x * (1.0/perplen); 
     nperp.y = perp.y * (1.0/perplen); 

     perpoffset.x = nperp.x * width * 0.5; 
     perpoffset.y = nperp.y * width * 0.5; 

     diroffset.x = ndir.x * width * 0.5; 
     diroffset.y = ndir.y * width * 0.5; 

      // p0 = start + perpoffset - diroffset 
      //p1 = start - perpoffset - diroffset 
      //p2 = end + perpoffset + diroffset 
      // p3 = end - perpoffset + diroffset 

     p0.x = start.x + perpoffset.x - diroffset.x; 
     p0.y = start.y + perpoffset.y - diroffset.y; 

     p1.x = start.x - perpoffset.x - diroffset.x; 
     p1.y = start.y - perpoffset.y - diroffset.y; 

     p2.x = end.x + perpoffset.x + diroffset.x; 
     p2.y = end.y + perpoffset.y + diroffset.y; 

     p3.x = end.x - perpoffset.x + diroffset.x; 
     p3.y = end.y - perpoffset.y + diroffset.y; 


     output.push_back(p0.x); 
     output.push_back(p0.y); 
     output.push_back(p1.x); 
     output.push_back(p1.y); 
     output.push_back(p2.x); 
     output.push_back(p2.y); 
     output.push_back(p3.x); 
     output.push_back(p3.y); 
    } 


} 

mais maintenant les lignes perpendiculaires regardent et le mal; ça devrait être de me donner des quads pour rendre ce que je suis en train de rendre, mais les points qu'il émet sont étranges. Est-ce que j'ai mal fait?

Merci

Answer 1

Vous ne calculez pas incorrectement. Il devrait être (y, -x), et non (x, -y). Je ne sais pas si c'est le seul bug. Celui-ci vient de me sauter dessus.

En aparté, je recommande fortement que vous définissez un type de vec2 utile, avec des aides utiles comme:

vec2 perp(vec2 v) { return vec2(v.y, -v.x); } 

De cette façon, votre code ressemblera à peu près le même que votre pseudo-code. Manipuler individuellement x et y est beaucoup plus sujet aux erreurs et plus difficile à lire. Il est assez simple de créer une classe de base à cet effet, mais il vaut mieux trouver une implémentation tierce pour éviter les erreurs comme celle-ci. La plupart des moteurs de jeu/graphisme/physique fournissent un tas de types et de fonctions utiles.