[Pytanie] grafika 3D Jak to zrobic ? ;c

[ProKoxFmsMetin2]

Siemka dzisiaj chce sie was zapytac tych zaawansowanych jak zrobic  ta oto grafike(napis)   :D

http://www.iv.pl/images/50227818107044049175.png

 

Nie piszcie jak nie wiecie ;c bo to beda zbedne posty

[Chris4132]

Jak chcesz zrobić to w 3D, to możesz marzyć, bo żeby ogarnąć podstawy chociażby blendera do takich prostych efektów trzeba poświęcić trochę czasu. Chociaż akurat ten obrazek, to można zrobić w 5 minut, ale żeby to umieć to trzeba popatrzeć na tutki. Chyba już łatwiej ogarnąć trochę tworzenie obrazków (np. na sygnatury itp.) w gimpie, tam jest samo sklejanie i edytowanie zasobów internetu, rzadziej się coś samemu tworzy od zera i masa tutków jest tutaj, na mpc forum.

[adrianostry]

kod graficzny.txt Witajcie, nie wiem czy dobrze trafiłem i czy to odpowiedni dział - mam do zrobienia projekt składający się z brył ( używany program to Microsoft Visual Studio 2010 z biblioteką Glut,Glui,Glew) Dostałem plik pomocny z którego usiłuję zrobić własny projekt który mam oddać na zaliczenie. Mam problem z zainicjowaniem dodatkowych brył na następne elementy projektu (samolot) przesyłam kod i bardzo bym prosił o jak najszybszą pomoc ( tylko w zainicjowaniu brył ) oto kod:

 

//////////////////////////////////////////////////////////////////////////////////////////

//

// Program wyświetlający zestaw figur w rzucie perspektywicznym.

// Długość boku lub promienia figur może być interaktywnie zmieniana za pomocą klawiszy '+' i '-'.

// Użyty materiał - mosiądz, obiekt oświetlony światłem sceny.

// Zmiana położenia obserwatora klawiszami strzałkami kursora

//

//////////////////////////////////////////////////////////////////////////////////////////

#include <glut.h>

#include "materials.h"

 

// Definicja stałych

#define DLUGOSC_BOKU            5.0

#define OBSERWATOR_ODLEGLOSC    20.0

#define OBSERWATOR_OBROT_X      20.0

#define OBSERWATOR_OBROT_Y      20.0

#define OBSERWATOR_FOV_Y        30.0  

 

GLfloat rotObsX = OBSERWATOR_OBROT_X;

GLfloat rotObsY = OBSERWATOR_OBROT_Y;

 

// Zmienne globalne

double  bok           = DLUGOSC_BOKU; // Długość boku sześcianu

int     szerokoscOkna = 800;

int     wysokoscOkna  = 600;

 

// Wskaźniki do wykorzystywanych kwadryk

GLUquadricObj *walec;

GLUquadricObj *dysk;

 

// Właściwości materiału - mosiądz

const GLfloat *ambient = BrassAmbient;

const GLfloat *diffuse = BrassDiffuse;

const GLfloat *specular = BrassSpecular;

const GLfloat *shininess = &BrassShininess;

 

// Tablica parametrów światła

GLfloat swiatlo[5][4] = {

    {0.0, 0.0, 0.0, 1.0},  // [0] otoczenie

    {1.0, 1.0, 1.0, 1.0},  // [1] rozproszenie

    {1.0, 1.0, 1.0, 1.0},  // [2] lustrzane

    {0.0, 0.0, 1.0, 0.0},  // [3] położenie

{0.0, 0.0, -1.0, 0.0}};// [4] kierunek świecenia

 

// Prototypy funkcji

void UstawMaterial();

void WlaczSwiatlo(void);

void RysujSzescian(double a);

void UstawParametryWidoku(int szer, int wys);

void WyswietlObraz(void);

void ObslugaKlawiatury(unsigned char klawisz, int x, int y);

void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y);

 

//////////////////////////////////////////////////////////////////////////////////////////

 

void UstawMaterial()

{

// Właściwości materiału

glMaterialfv(GL_FRONT, GL_AMBIENT, ambient);

glMaterialfv(GL_FRONT, GL_DIFFUSE, diffuse);

glMaterialfv(GL_FRONT, GL_SPECULAR, specular);

glMaterialf(GL_FRONT, GL_SHININESS, *shininess);

}

 

void WlaczSwiatlo(void)

{

  

  // Odblokowanie zerowego źrodła światła

  glEnable(GL_LIGHT0);

 

  // Definiowanie źródła światła

  glLightfv(GL_LIGHT0, GL_AMBIENT, swiatlo[0]);

  glLightfv(GL_LIGHT0, GL_DIFFUSE, swiatlo[1]);

  glLightfv(GL_LIGHT0, GL_SPECULAR, swiatlo[2]);

  //glLightfv(GL_LIGHT0, GL_POSITION, swiatlo[3]);  

  glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, swiatlo[4]);  

}

 

void InicjujKwadryki()

{

// Zainicjowanie walca 

walec = gluNewQuadric();

gluQuadricDrawStyle(walec, GLU_FILL);

  

// Zainicjowanie górnej podstawy walca 

dysk = gluNewQuadric();

gluQuadricDrawStyle(dysk, GLU_FILL);

}

 

void UsunKwadryki()

{

// Usunięcie kwadryki walca 

gluDeleteQuadric(walec);

  

// Usunięcie kwadryki górnej podstawy walca 

gluDeleteQuadric(dysk);

}

 

//////////////////////////////////////////////////////////////////////////////////////////

// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.

// Środek sześcianu znajduje się w punkcie (0,0,0).

void RysujSzescian(double a)

{

// Początek tworzenia układu współrzędnych

 

glBegin(GL_LINES);

 

// Os X

glColor3f(1.0, 0.0, 0.0);

glVertex3f(-20.0, 0.0, 0.0);

glVertex3f(20.0, 0.0, 0.0);

 

// Os Y

glColor3f(0.0, 1.0, 0.0);

glVertex3f(0.0, -20.0, 0.0);

glVertex3f(0.0, 20.0, 0.0);

 

// Os Z

glColor3f(0.0, 0.0, 1.0);

glVertex3f(0.0, 0.0, -20.0);

glVertex3f(0.0, 0.0, 20.0);

 

// Koniec tworzenia układu współrzędnych

glEnd();

 

UstawMaterial();

 

WlaczSwiatlo();

 

// Przygotowanie stosu macierzy modelowania

glPushMatrix();

 

// Rysowanie sześcianu

glPushMatrix();

 

glRotatef(90.0, 0.0, 0.0, 1200.0); //90.0, 1.0, 0.0, 0.0 

glTranslatef(1.30, -10.0, 10.0); //0.0, -a/4.0, 0.0

glScalef(0.25, 3.0, 8.0); //0.0, 0.0, 0.0

 

glutSolidCube(a);

 

glPopMatrix();

 

// Rysowanie walca (cylinder bez podstaw)

glPushMatrix();

 

glRotatef(90.0, 1.0, 5.0, 1.0); // kąt przesunięcia, obrót góra, przechył,obrót

glTranslatef(0.0, 0.0, 0.0); // 0.0,(przesunięcie do przodu T) 0.0,(przesunięcie w górę) -a/2.0 (przesunięcie w prawo)

glScalef(1.0, 1.0, 10.0); //1.0,(wysokosc) 1.0,(szerokosc) 1.0( dlugosc)

 

gluCylinder(walec, 2.0, 2.0, 2.0, 20, 10); //a/2.0(szerokosc), a/3.0(wyprostowanie), a/2.0(ponowne wydlurzenie), 20, 10)

 

 

glPopMatrix();

 

// Rysowanie górnej podstawy walca (dysk) 

glPushMatrix();

 

glRotatef(90.0, 0.0, 0.0, 0.0); // 0.0, 0.0, 0.0, 0.0

glTranslatef(0.0, 0.0, 0.0); //0.0, 0.0, 1.0

glScalef(0.0, 0.0, 0.0); //0.0, 0.0, 0.0

 

gluDisk(dysk, a/0.0, 2.0, 20, 10); //a/0.0, 2.0, 20, 10

 

glPopMatrix();

 

// Rysowanie kuli na górze 

glPushMatrix();

 

glRotatef(90.0, 0.0, 1.0, 0.0); //90.0, 0.0, 1.0, 0.0

glTranslatef(0.0, 0.0, 0.0); //0.0, 2.0, 0.0

glScalef(1.0, 1.0, 0.75); //0.0,(wysok) 0.0,(szer) 0.0(dlu)

 

glutSolidSphere(2.0, 20, 20); //a/4.0(pomniejszenie/powiekszenie), 20, 20

glPopMatrix();

}

 

//////////////////////////////////////////////////////////////////////////////////////////

// Funkcja ustawiająca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna

// być wywoływana każdorazowo po zmianie rozmiarów okna programu.

void UstawParametryWidoku(int szer, int wys)

{

  // Zapamiętanie wielkości widoku

  szerokoscOkna = szer;

  wysokoscOkna  = wys;

 

  // Ustawienie parametrów viewportu

  glViewport(0, 0, szerokoscOkna, wysokoscOkna);

 

  // Przejście w tryb modyfikacji macierzy rzutowania

  glMatrixMode(GL_PROJECTION);

  glLoadIdentity();

  gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);

}

 

 

//////////////////////////////////////////////////////////////////////////////////////////

// Funkcja wyświetlająca pojedyńcza klatkę animacji

void WyswietlObraz(void)

{

  // Wyczyszczenie bufora koloru i bufora głębokości

  glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

 

  // Przejście w tryb modyfikacji macierzy przekształceń geometrycznych

  glMatrixMode(GL_MODELVIEW);

 

  // Zastąpienie aktywnej macierzy macierzą jednostkową

  glLoadIdentity();

 

  // Ustalenie położenia obserwatora

  glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);

  glRotatef(rotObsX, 1, 0, 0);

  glRotatef(rotObsY, 0, 1, 0);

 

  // Włączenie oświetlenia

  glEnable(GL_LIGHTING);

   

  // Włączenie automatycznej normalizacji wektorów normalnych

  glEnable(GL_NORMALIZE);

  

  // Narysowanie sześcianu

  RysujSzescian(bok);

 

  // Przełączenie buforow ramki

  glutSwapBuffers();

}

 

//////////////////////////////////////////////////////////////////////////////////////////

// Funkcja klawiszy specjalnych

void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)

{

  switch(klawisz)

    {

    case GLUT_KEY_UP:

      rotObsX = (rotObsX < 360.0) ? rotObsX + 1.0 : rotObsX;

      break;

 

    case GLUT_KEY_DOWN:

      rotObsX = (rotObsX > 0.0) ? rotObsX - 1.0 : rotObsX;

      break;

 

    case GLUT_KEY_LEFT:

      rotObsY = (rotObsY > -90.0) ? rotObsY - 1.0 : rotObsY;

      break;

 

    case GLUT_KEY_RIGHT:

      rotObsY = (rotObsY < 90.0) ? rotObsY + 1.0 : rotObsY;

      break;

    }

}

 

//////////////////////////////////////////////////////////////////////////////////////////

// Funkcja obsługi klawiatury

void ObslugaKlawiatury(unsigned char klawisz, int x, int y)

{

  if(klawisz == '+')

      bok *= 2.0;

  else if (klawisz == '-')

      bok /= 2.0;

  else if (klawisz == 27)

      exit(0);      

}

 

//////////////////////////////////////////////////////////////////////////////////////////

// Główna funkcja programu

int  main(int argc, char **argv)

{

  // Zainicjowanie biblioteki GLUT

  glutInit(&argc, argv);

 

  // Ustawienie trybu wyświetlania

  glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);

 

  // Ustawienie położenia dolnego lewego rogu okna

  glutInitWindowPosition(100, 100);

 

  // Ustawienie rozmiarów okna

  glutInitWindowSize(szerokoscOkna, wysokoscOkna);

 

  // Utworzenie okna

  glutCreateWindow("Oświetlony zestaw figur");

 

  // Odblokowanie bufora głębokości

  glEnable(GL_DEPTH_TEST);

 

  // Ustawienie wartosci czyszczacej zawartosc bufora glebokosci

  glClearDepth(1000.0);

 

  // Ustawienie koloru czyszczenia bufora ramki

  glClearColor (0.0f, 0.0f, 0.3f, 0.0f);

 

  // Wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).

  //glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

  

  // Zarejestrowanie funkcji (callback) odpowiedzialnej za wyświetlanie ramki

  glutDisplayFunc(WyswietlObraz);

 

  // Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy

  // zmieniane sa rozmiary okna

  glutReshapeFunc(UstawParametryWidoku);

 

  // Zarejestrowanie funkcji wykonywanej, gdy okno nie obsługuje żadnych zadań

  glutIdleFunc(WyswietlObraz);

 

  // Zarejestrowanie funkcji obsługi klawiatury

  glutKeyboardFunc(ObslugaKlawiatury);

 

  // Zarejestrowanie funkcji obsługi klawiszy specjalnych

  glutSpecialFunc(ObslugaKlawiszySpecjalnych);

 

   // Zainicjowanie obiektów kwadryk

  InicjujKwadryki();

 

  // Obsługa głównej petli programu (wywoływanie zarejestrowanych callbacków

  // w odpowiedzi na odbierane zdarzenia lub obsługa stanu bezczynności)

  glutMainLoop();

 

  // Usunięcie obiektów kwadryk

  UsunKwadryki();

 

  return 0;

}