M.M. <m...@W...gazeta.pl> napisał(a):

> slawek <s...@h...pl> napisał(a):
>
> >
> > Użytkownik <f...@W...gazeta.pl> napisał w wiadomości grup
> > dyskusyjnych:jlol4d$h1d$...@i...gazeta.pl...
> > > M.M. <m...@W...gazeta.pl> napisał(a):
> > >
> > >> <f...@g...SKASUJ-TO.pl> napisał(a):
> > >>
> > >> > mam cztery wierzcholki prostokata
> > >> >
> > >> > int Ax, Ay, Bx, By, Cx, Cy, Dx, Dy;
> > >> >
> > >> > ktore maja przypisane wartosci, potrzebuje te
> > >> > wartosci przwpisac do
> > >> >
> > >> > int upX, upY, downX, downY, leftX, leftY, rightX, rightY;
> > >> >
> > >> > zgodnie z nazwami tj ten najbardziej z lewej do leftX leftY
> > >> > itp, jak to zrobic w prosty sposob?
> > >>
> > >> Funkcje min i max będą przydatne.
> > >
> > > to by bylo chyba za dlugie, chyba moge to zrobic sprawdzajac
> > > w jakiej cwiartce jest wektor B-A (mozna zalozyc ze ABCD sa
> > > uporzadkowane np prawoskretnie wiec chyba powinno byc ok)
> >
> > Posortować oddzielnie (Ax, Bx, Cx, Dx) i (Ay, By, Cy, Dy).
> >
> > Lewe są te z najmniejszymi x-sami, górne te z najmniejszymi
(największymi?
> > zależy od przyjętego układu współrzędnych) y-kami.
> >
> > Trochę logiki i powinno działać.
> >
> > Funkcje min i max nie będą (chyba) szybsze niż if-else .
> >
> > Najogólniej? Są 24 przypadki, wystarczy "zajarzyć" który z nich i już
jest
> > prosto.
>
> Jeśli to ma być szybko, to bez ifów i z wykorzystaniem specyficznych cech
> danych wejściowych. Jeśli zmienne są nazywane leftX i leftY to rozumiem,
> że chodzi tylko o takie kwadraty które da się opisać czterema liczbami:
> dwie współrzędne lewego górnego rogu i dwie prawego dolnego. Do wyświetlania
> na monitorze w zupełności wystarczy 16 bitów, daje to sporą rozdzielczość
> 65tys na 65tys punktów logicznych czy tam fizycznych. Czyli apropo
> struktury danych mamy cztery liczby upakowane do jednej 64 bitowej,
najlepiej
> jakby ona znalazła się w rejestrze.
>
> Mamy cztery dane wejściowe:
> Ax, Ay, Bx, By, Cx, Cy, Dx, Dy
> Być może to już jest błędem, może algorytm wypluwający te dane da się
> tak przebudować, aby dawał tylko 4 liczby, gdyż każda współrzędna dla
> prostokąta obróconego o wielokrotność 90 stopni występuje dwa razy. Jeśli
> się da algorytm wypluwający przebudować, to wystarczy porównać dwie
> liczby if( a < b ) szesnastobitowe utworzone odpowiednio z bitów 0-15 i
> 32-47. W przypadku gdy współrzędne są podawane tak jak zwykle, czyli
> najpierw x a potem y, to w przypadku gdy a < b wiemy że lewy górny punkt
> jest zakodowany w bitach 0-31, prawy dolny w bitach 32-64 i nic nie musimy
> zmieniać. W przypadku gdy a > b to musimy zamienić 32 bity młodsze ze
starszymi
> .
>
> Mniej/więcej coś takiego:
> uint64 swp_corners( uint64 input ) {
> const uint32 tmp = ( ( input & x_corner_1 ) >> offset_x1 ) < ( ( input &
> x_corner_2 ) >> offset_x2 );
> return (input>>(32*tmp))|(input<<(32*tmp));
> }
>
> Można pomyśleć jeszcze jak w tmp uzyskać jedynkę gdy wynik porównywania
> jest prawdziwy i zero gdy jest nieprawdziwy w sposób niewymagający użycia
> operatora mniejszości. Tak żeby kompilator nie wstawiał instrukcji
> jum_if_less.
>

nienie chodzi mi o cos innego


a b c d to wierzcholki przekrzywionego (obroconego o kat alfa)
prostokata, mozna tez zalozyc ze sa uporzadkowane np prawoskretnie

zrobilem cos takiego

WX_ = qBx-qAx;
WY_ = qBy-qAy;

if(WX_>0)
{
if(WY_>0)
{
upx = qBx; upy = qBy;
rightx = qCx;righty = qCy;
downx = qDx; downy = qDy;
leftx = qAx; lefty = qAy;
}
else
{
upx = qAx; upy = qAy;
rightx = qBx;righty = qBy;
downx = qCx; downy = qCy;
leftx = qDx; lefty = qDy;
}

}
else if(WX_<0)
{
if(WY_>0)
{
// dabc
upx = qCx; upy = qCy;
rightx = qDx;righty = qDy;
downx = qAx; downy = qAy;
leftx = qBx; lefty = qBy;



}
else
{
upx = qDx; upy = qDy;
rightx = qAx;righty = qAy;
downx = qBx; downy = qBy;
leftx = qCx; lefty = qCy;


}

}
else
{
}

to uporzadkowanie jest mi potrzebne by pozniej
wyrysowac quada na ekranie przez cos w stylu

dxleft = ((upx-leftx)<<10)/(lefty-upy);
dxright = ((upx-rightx)<<10)/(righty-upy);
xs = upx<<10;
xk = upx<<10;



int y = upy;

int dxs = dxleft;
int dxk = dxright;


for(;;)
{

drawPozioma(y, xs>>10, xk>>10, color);

if(y==downy) break;

y--;
xs+=dxs;
xk+=dxk;

if(y==lefty) dxs = dxright;
if(y==righty) dxk = dxleft;


}


ale trzeba uwzglednic tez przypadki gdy punkty w gornej lini sa dwa
(i to wcale nie jest wtedy koniecznie prosty prostakat)
- bez przerwy leca jakies bledy i nie mog edefekto doprowadzic
tego prostego cholerstwa do dzialania jest dziwnie frustrujace
(podobnie nie moge znalezc dobrego przykladu na renderowanie
przekrzywionych prostokatow w necie)




--
Wysłano z serwisu Usenet w portalu Gazeta.pl -> http://www.gazeta.pl/usenet/