Obliczenie współrzędnych sześciokąta

Witam. Piszę program komputerowy, który wyświetla mapę składającą się z sześciokątów. Chciałbym móc podzielić każdy sześciokąt na elementy składowe ażeby na nich operować. Potrzebuję obliczyć współrzędne v3, v4 (dla każdego z trójkątów).

float outerRadius = 10.0f;
float innerRadius = outerRadius * 0.866025404f;
float n = 0.8f;

float hexVertices[ ] =
{
    0.0f, outerRadius,
    innerRadius, outerRadius * 0.5f,
    innerRadius, - outerRadius * 0.5f,
    0.0f, - outerRadius,
    - innerRadius, - outerRadius * 0.5f,
    - innerRadius, outerRadius * 0.5f,
    0.0f, outerRadius
};

// ... --- ... //

for(int direction=0; direction<6; direction++)
{
    v1x = hexVertices[2*direction] * n;
    v1z = hexVertices[2*direction+1] * n;

    v2x = hexVertices[2*(direction+1)] * n;
    v2z = hexVertices[2*(direction+1)+1] * n;

    // v3x = v1x ...
    // v3z = v1z ...

    // v4x = v2x ...
    // v4z = v2z ...

    v5x = hexVertices[2*direction];
    v5z = hexVertices[2*direction+1];

    v6x = hexVertices[2*(direction+1)];
    v6z = hexVertices[2*(direction+1)+1];
}

Jeśli sześciokąty są foremne (równoboczne), to współrzędne punktów liczymy analogicznie do wyznaczania punktów okręgu.

Okrąg ma 360 stopni.
Żeby wyznaczyć współrzędne punktu o zadanej pozycji kątowej a na okręgu o promieniu r, trzeba użyć wzoru:
vx = cos(a) * r;
vy = sin(a) * r;

Pamiętaj, że funkcje trygonometryczne w C++ przyjmują kąty w radianach, więc będziesz musiał skonwertować stopnie do radianów.

Tak się tworzy przybliżony kształt okręgu w grafice. Tylko, że punktów jest więcej niż w sześcikącie:

@Spine Wiem o tym, właśnie od tego są v5 i v6. Ja potrzebuję obliczyć v3 i v4, które są prostopadłe do ściany sześciokąta oraz v5, v6 które są graniczne.

No to narysuj to sobie w układzie współrzędnych i pomyśl...

Punkt 2 ma taką samą pozycję x jak punkt 1.
Punkt 2 ma ujemną pozycję y punktu 1.

Punkt 3 ma taką samą pozycję x jak punkt 0.
Punkt 3 ma ujemną pozycję y punktu 0.

Punkt 4 ma taką samą pozycję y jak punkt 2.
Punkt 4 ma ujemną pozycję x punktu 2.

Itd...

Mi tam generuje poprawnie, próbuję zabrać się za zewnętrzne ściany sześciokątów.

To jaki to problem, żebyś wykonał te same obliczenia dla zewnętrznych punktów, co dla wewnętrznych?
Tylko inny promień podstawiasz.

No dobra, tylko jakie ?

Może zacznij od przeczytania moich postów.
Wszystko Ci opisałem.
Jeśli czegoś z nich nie rozumiesz, to pytaj.

A jeśli chodzi Ci o coś innego, to lepiej opisz swój problem.

Napisałeś:

tBane napisał(a):

Mi tam generuje poprawnie, próbuję zabrać się za zewnętrzne ściany sześciokątów.

I jak czytający ma to odebrać?
Ja to zrozumiałem, że wewnętrzne hexy udało Ci się zrobić i teraz pracujesz nad dodaniem do hexa obwódki.

Potrzebuje uzyskać współrzędne V3, V4 dla każdego z sześciu trójkątów tworzących sześciokąt.

Co to jest to „V3”, „V4”? Współrzędne trzeciego, czwartego wierzchołka? Wg numeracji z którego obrazka?

Jakie jest „n”? Bo z Twojego rysunku to nie wynika, może być dowolne (w zakresie od zera do „promienia” sześcianu).

Czyli chodzi Ci o trzeci rysunek z Twojego pierwszego posta?
Mogłeś tak od razu napisać, bo wszędzie są numerki wierzchołków...

Żeby dostać v3 musisz przesunąć v1 o wektor prostopadły do v1-v2.
Tak samo musisz przesunąć v4.

Ten wektor prostopadły normalizujesz i mnożysz przez określoną odległość. A potem wynik dodajesz do v1 i v2, aby otrzymać v3 i v4.

Obliczenia do pewnego momentu są podobne jak tutaj: https://alienryderflex.com/polygon_inset/
Tylko, że musisz wektor prostopadły liczyć odwrotnie - bo ma iść na zewnątrz.

@Spine wiem to mniej więcej, ale sam przepisać to na kod nie potrafię :-/

|p0 p5| = |p0 p6| = |p5 p6| = r

|p3 p5|   r - n
------- = -----
  r/2       r

Znając współrzędne p5 i p6 oraz długości |p5 p6| i |p3 p5| wyliczysz współrzędne p3.

Oczywiście proporcję można pomnożyć przez r. Zostawiłem w tej postaci, żeby było widać zastosowanie twierdzenia Talesa.

dzięki @-daniel-, teraz mniej więcej wiem jak to zrobić.

float d = (1.0f - n) * outerRadius / 2.0f;

edit//
jednak nie mam pojęcia - nie znam się za bardzo na wektorach a w necie są słabe poradniki.

Niestety w takim przypadku mi się najlepiej wraca do starej metody kartka+długopis.

 d     x3 - x5
--- = ---------
 r     x6 - x5

           d
x3 - x5 = --- (x6 - x5)
           r

           d
x3 = x5 + --- (x6 - x5)
           r

Analogicznie dla y, tylko za każdym razem trzeba pilnować znaków, czyli co od czego odjąć.
Przypuszczalnie gdy już zrobisz kilka wierzchołków wyjawi się ogólna zasada, ale mi się nie chciało tego liczyć.

Jednak nic nie rozumiem i nic z tego mi nie wyszło.
Zamykam temat bo i tak tego nie zrozumiem.

To wyżej to jest pokazane jak wyprowadzić wzór na współrzędną x punktu P3 (tak znowu Tales). Niestety przy grafice trzeba trochę umieć we wzory.

Po konwersji z "kartki" na kod będzie coś mniej więcej tak:

P3.x = P5.x + (d/r) * (P6.x - P5.x)
P3.y = P5.y + (d/r) * (P6.y - P5.y)

Zakładam, że współrzędne P5 i P6 masz wyliczone, a r to Twój outerRadius.

P4.x = P6.x + (d/r) * (P5.x - P6.x)
P4.y = P6.y + (d/r) * (P5.y - P6.y)

Da się pewnie też wyliczyć wzór ogólny dla sześciokąta foremnego, bo dla P3 wygląda, że y = r - sin(30) * d, a x = sin(60) * d.

tBane napisał(a):

Jednak nic nie rozumiem i nic z tego mi nie wyszło.
Zamykam temat bo i tak tego nie zrozumiem.

Nie poddawaj się!

tBane napisał(a):

Witam. Piszę program komputerowy, który wyświetla mapę składającą się z sześciokątów. Chciałbym móc podzielić każdy sześciokąt na elementy składowe ażeby na nich operować. Potrzebuję obliczyć współrzędne v3, v4 (dla każdego z trójkątów).

float outerRadius = 10.0f;
float innerRadius = outerRadius * 0.866025404f;
float n = 0.8f;

float hexVertices[ ] =
{
    0.0f, outerRadius,
    innerRadius, outerRadius * 0.5f,
    innerRadius, - outerRadius * 0.5f,
    0.0f, - outerRadius,
    - innerRadius, - outerRadius * 0.5f,
    - innerRadius, outerRadius * 0.5f,
    0.0f, outerRadius
};

// ... --- ... //

for(int direction=0; direction<6; direction++)
{
    v1x = hexVertices[2*direction] * n;
    v1z = hexVertices[2*direction+1] * n;

    v2x = hexVertices[2*(direction+1)] * n;
    v2z = hexVertices[2*(direction+1)+1] * n;

    // v3x = v1x ...
    // v3z = v1z ...

    // v4x = v2x ...
    // v4z = v2z ...

    v5x = hexVertices[2*direction];
    v5z = hexVertices[2*direction+1];

    v6x = hexVertices[2*(direction+1)];
    v6z = hexVertices[2*(direction+1)+1];
}

1. No to bierzemy obrazek:

Widzisz, że wierzchołek 1 i wierzchołek 2 tworzą odcinek.
Potrzebujemy obliczyć wektor prostopadły do tego odcinka. Nazwijmy go vP.
Jak policzyć wektor prostopadły? Objaśnienie z ChatGPT masz tutaj: https://chat.openai.com/share/8c7ad73a-ae96-4251-a9b1-227f5bf88a2d

2. Otrzymany wektor prostopadły musimy znormalizować, czyli ustawić jego długość na 1.0
   Potrzebne nam to będzie, aby potem łatwo ustawić długość odcinka v1=>v3, v2=>v4.
   Żeby znormalizować wektor, trzeba podzielić jego składowe przez długość wektora.
   Dłuższe wyjaśnienie: https://chat.openai.com/share/46d0ea92-4758-4f34-ac82-308547a5e563

3. Kiedy mamy już znormalizowany wektor, to pozostaje nam go przemnożyć przez ustaloną długość distance, która określa jak daleko od hexa mają znajdować się v3, v4.

4. Na koniec ustawiamy pozycje v3, v4. Czyli przesuwamy v1 i v2 o wektor otrzymany w poprzednich punktach.
   v3 = v1 + vP;
v4 = v2 + vP;

5. Uzupełniłem zakomentowaną część Twojego kodu:

float outerRadius = 10.0f;
float innerRadius = outerRadius * 0.866025404f;
float n = 0.8f;

float hexVertices[ ] =
{
    0.0f, outerRadius,
    innerRadius, outerRadius * 0.5f,
    innerRadius, - outerRadius * 0.5f,
    0.0f, - outerRadius,
    - innerRadius, - outerRadius * 0.5f,
    - innerRadius, outerRadius * 0.5f,
    0.0f, outerRadius
};

// ... --- ... //

for(int direction=0; direction<6; direction++)
{
    v1x = hexVertices[2*direction] * n;
    v1z = hexVertices[2*direction+1] * n;

    v2x = hexVertices[2*(direction+1)] * n;
    v2z = hexVertices[2*(direction+1)+1] * n;

    // wektor z v1 do v2
    v12x = v2x - v1x;
    v12z = v2z - v1z;

    // wektor prostopadły do tego wektora
    vPx = -v12z;
    vPz = v12x;

    // normalizacja wektora vP
    float vPlength = std::sqrt(vPx * vPx + vPz * vPz);
    vPx = vPx / vPlength;
    vPz = vPz / vPlength;

    // ustawienie długości wektora vP
    vPx = vPx * distance;
    vPz = vPz * distance;

    // ustawienie pozycji v3, v4
    v3x = v1x + vPx;
    v3z = v1z + vPz;

    v4x = v2x + vPx;
    v4z = v2z + vPz;

    v5x = hexVertices[2*direction];
    v5z = hexVertices[2*direction+1];

    v6x = hexVertices[2*(direction+1)];
    v6z = hexVertices[2*(direction+1)+1];
}

Oczywiście musisz zadeklarować niezadeklarowane zmienne, oraz dołączyć nagłówek cmath.
Mogą się zdarzyć jakieś niedociągnięcia. Pisane bez kompilowania.

Dziękuję za pomoc @-daniel- oraz @Spine. Teraz rozumiem.