jak narysowac na 2d obiekt 3d ?

0

witam,
pomijajac sprawy implementacji czy ktos moglby powiedziec, jak przy ustalonych wspolrzednych x,y,z kamery i kierunku jej patrzenia oraz punktach zawieszonych w przestrzeni (dla ulatwienia wierzcholki szescianu) wyswietlic je na powierzchni 2d (np przy pomocy winbgim, allegro, sdl). chodzi o przeksztalcenie znajdujace dla punktow z przestrzeni ich 'odpowieniki' na plaszczyznie tak by moc to przeksztalcenie wykorzystac do zwizualizowania obracania sie bryly 3d.

moze ma ktos jakies materialy z uczelni albo chociaz pomysl pod jakim haslem to googlowac?

pozdrawiam

0

Poszukaj sobie o macierzach przeksztalcen.

0

3d na 2d ... Programowanie 3D

0

IMHO najlepiej uzyc jakiejs gotowej biblioteki do grafiki 3D, typu OpenGL albo DirectX.

0
Ghostek napisał(a)

IMHO najlepiej uzyc jakiejs gotowej biblioteki do grafiki 3D, typu OpenGL albo DirectX.

no chyba ze chcesz miec fotorealizm to wtedy tylko raytracing i podobne :P

0
ADuch napisał(a)

3d na 2d ... Programowanie 3D

Aduch - wielkie dzieki za linka i artykul.

jeszcze nie sprawdzilem jak dziala, ale rodzi mi sie pytanko jak zrobic takie przeksztalcenie powierzchni zeby pasowalo do sciany powstalego szescianu.

<url>www.zhr.pl/~p.buczkowski/przeksztalcenie.jpg</url>

ponawiam prosbe o nazwanie tego o czym tu rozmawiamy, bo ciagle nie wiem jak wyszukiwac dalszych informacji (mile widziane angielskie nazwy obok polskich). ma ktos wiecej materialow na ten temat ?

pozdrawiam i dziekuje za dotychczasowa pomoc.

0

np tak jak tutaj masz interpolacje
Programowanie 3D cz. III
tyle że zamiast interpolować C, interpolujesz dwie współrzędne U,V odpowiadające koordynatą pikseli w bitmapie.
Jak sie uporasz z tym to poczytaj o korekcji perspektywy ( technologia wykorzystywana od Quake 1 ), bez tego uzyskasz nieprawidłowości w obrazie http://upload.wikimedia.org/wikipedia/commons/5/57/Perspective_correct_texture_mapping.jpg

A to jeszcze do poprzedniego tematu :
http://en.wikipedia.org/wiki/3D_projection

cepa napisał(a)
Ghostek napisał(a)

IMHO najlepiej uzyc jakiejs gotowej biblioteki do grafiki 3D, typu OpenGL albo DirectX.

no chyba ze chcesz miec fotorealizm to wtedy tylko raytracing i podobne :P

Nie do końca, za pomocą tych bibliotek możesz sie wspomóc w działaniu, np pixel shader

0

dzis udalo mi sie naskrobac to

user image

#include <cstdlib>
#include <iostream>
#include <winbgim.h>
#include <vector>
#include <conio.h>

using namespace std;

int windoww(1024), windowh(768), focus(400), scale(1), CAMZ(-2);

struct point{
      float x, y, z;
      void draw(){
            circle(int(x*focus/(z-CAMZ) ), int(y*focus/(z-CAMZ) ), 2);
            cout << int(x*focus/(z-CAMZ) ) << "   " << int(y*focus/(z-CAMZ) ) <<" "<<x<<" "<<y<<" "<<z<<endl;
      }
      int getx(){return int(x*focus/(z-CAMZ) ); };
      int gety(){return int(y*focus/(z-CAMZ) ); };
      point(float xx=0.0, float yy=0.0, float zz=0.0): x(xx), y(yy), z(zz) {};
};

struct poly{
      int a, b, c;
      poly(int aa=0, int bb=0, int cc=0): a(aa), b(bb), c(cc) {};
};
      



struct model{
      vector<point> vertices;
      vector<poly> polygons;
      
      void drawpoints(){
            for(int i=0; i<vertices.size(); ++i){
                  vertices[i].draw() ;     
            }
      }
      
      void drawpolygons(){
            for(int i=0; i<polygons.size(); ++i){
                  line(vertices[polygons[i].a].getx(), vertices[polygons[i].a].gety(), vertices[polygons[i].b].getx(), vertices[polygons[i].b].gety());
                  line(vertices[polygons[i].b].getx(), vertices[polygons[i].b].gety(), vertices[polygons[i].c].getx(), vertices[polygons[i].c].gety());
                  line(vertices[polygons[i].c].getx(), vertices[polygons[i].c].gety(), vertices[polygons[i].a].getx(), vertices[polygons[i].a].gety());
            }
      }
      
      void movex(float f){ for(int i=0; i<=vertices.size(); ++i){ vertices[i].x+=f; } }
      void movey(float f){ for(int i=0; i<=vertices.size(); ++i){ vertices[i].y+=f; } }
      void movez(float f){ for(int i=0; i<=vertices.size(); ++i){ vertices[i].z+=f; } }
      
      void load(){
            int count1, count2;
            
            float tmp1, tmp2, tmp3;
            cin >> count1 >> count2;
            
            for(int i=0; i<count1; ++i){
                  cin >> tmp1 >> tmp2 >> tmp3;
                  vertices.push_back(point(tmp1, tmp2, tmp3+5.0)); 
                  cout << tmp1 << " " << tmp2 << " " << tmp3 << " $$ ";
                  vertices[vertices.size()-1].draw();                                 
            }
            
            
            for(int i=0; i<count2; ++i){
                  cin >> tmp1 >> tmp2 >> tmp3;
                  polygons.push_back(poly((int)tmp1, (int)tmp2, (int)tmp3));                  
            }
      }
};

int main()
{
      
      initwindow(windoww,windowh);
      setviewport((int)(windoww/2),(int)(windowh/2),(int)(windoww/2),(int)(windowh/2), false);
      
      model mymodel;
      mymodel.load();
      
      
      

      int page=1;
      float rate=0.05;
      char c;
      
      ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
   
      while(1){
            
                                                                              //poczatek kodu podwojnego buforowania
            if(page==1){                        
                  setvisualpage(1);
                  setactivepage(2);
                  page=2;
            }else{
                  setvisualpage(2);
                  setactivepage(1);
                  page=1;
            }
            delay(20);
            cleardevice();                      
                                                                              //koniec kodu podwojnego buforowania
      
      
            mymodel.drawpolygons();
      
            c=0;
            if(kbhit()) c=getch();
            switch(c){
                  case 'a': mymodel.movex(-rate); break;
                  case 'd': mymodel.movex(rate); break;
                  case 'w': mymodel.movey(-rate); break;
                  case 's': mymodel.movey(rate); break;
                  case 'q': mymodel.movez(-rate); break;
                  case 'e': mymodel.movez(rate); break;
                  case '1': focus-=5; break;
                  case '2': focus+=5; break;
            }
            
      
      
      }
      ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
      system("PAUSE");

}

wiem ze to nie jest szczyt inzynierii programowania, bylo pisane na kolanie tylko zeby sprawdzic efekt.

programowi zapodaje sie dane z txt np

<url>www.zhr.pl/~p.buczkowski/torus.txt</url>
czy
<url>www.zhr.pl/~p.buczkowski/teapot.txt</url>

binarka jest tu <url>www.zhr.pl/~p.buczkowski/halloworld.exe</url>

dzieki za linki, dzis juz tego pewnie nie przeczytam ale o postepach bedzie w nastepnym poscie.

heh, moze chcecie mnie zabic za to ze nie mam jednego a chodzi mi po glowie nastepne, ale:
jak trudne sa proste cienie ? : >

0

Proste cienie, to tylko rzut punktów na jakąś powierzchnie, tzn masz obiekt który składa sie z N poligonów, wszystkie wierzchołki każdego z poligonów rzutujesz na płaszczyznę ( podłogę ) i rysujesz jako czarne trójkąty z przezroczystością w jakimś dowolnym procencie ( od tego zależy jak intensywny jest cień ), jednak takie podejście wiąże się z dużymi zakłóceniami obrazu to znaczy mogą powstać efekty niejednolitego cienia, w niektórych miejscach moze on być ciemniejszy w innych jaśniejszy, ponieważ rzutujesz trójkąt na jedną płaszczyzne to kilka z nich moze sie pokryć i wzmocnić cień w tym miejscu. Takie błędy niweluje sie za np. pomocą bufora "stencil" w OpenGl, ponadto rzutuje się nie wszystkie poligony a jedynie krawędzie obiektu, tzn krawędzie mam na myśli elementy które rozgraniczają część oświetloną od tej zasłoniętej.

0

mam na mysli cienie na samym obiekcie, jego nierownomierne oswietlenie

0

aha chodzi ci o oświetlenia na obiekcie? no to masz w linku który ci dałem "Gouraud shading"
jeśli łączysz to z teksturowaniem, to kolor ostateczny piksela liczysz tekstura(u,v)*c
jeśli kolor tekstury masz z przedziału 0,1..255 a C jest <0;1> no to wystarczy wziąć cześc całkowitą i gotowe. Jeżeli natomiast zarówno kolor tekstury jak i kolor oświetlenia masz w przedziale 0,1..255 no to końcowy wynik dzielisz przez 255;
Jeżeli tekstura jest w formacie RGB to tę operacje wykonujesz na każdej jej składowej, jeżli oświetlenie jest również RGB, to mnożysz odpowiednio R oświetlenia z R tekstury itd.

1 użytkowników online, w tym zalogowanych: 0, gości: 1