/////////////////////////////////////// GERDA //////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#include <GL/glut.h>
#include <math.h>
// Definicja stalych
float OBSERWATOR_ODLEGLOSC = 25.0;
float OBSERWATOR_OBROT_X =10.0;
float OBSERWATOR_OBROT_Y =10.0;
float OBSERWATOR_OBROT_Z =0.0;
#define OBSERWATOR_FOV_Y 40.0
#define DLUGOSC_BOKU 5.0
// Zmienne globalne
int szerokoscOkna = 1000;
int wysokoscOkna = 600;
float zzz=0;
double bok = DLUGOSC_BOKU;
double krec = 0.0;
double bolce = 0.0;
// Prototypy funkcji
void Zamek();
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
//////////////////////////////////////////////////////////////////////////////////////////
void RysujZamek()
{
float x,y,z,angle,angle2;
float Pi=3.14159265;
angle=-Pi/2;
glPushMatrix();
//---------------------------------------------------//
// obudowa
glPushMatrix();
glColor3f(0.8,0.6,0.0);
glScalef(6,6,1);
glutSolidCube(1);
glPopMatrix();
// uchwyt - kolko
// obkręcanko
glPushMatrix();
glRotatef(krec,0,0,1);
// ------ //
glPushMatrix();
glColor3f(0.1,0,0.1);
GLUquadricObj *uchwyt;
uchwyt=gluNewQuadric();
glTranslatef(0.0,0.0,0.1);
gluCylinder(uchwyt,1.0,1.0,0.5,40,45);
gluDeleteQuadric(uchwyt);
glPopMatrix();
// podstawy cylindrów
glPushMatrix();
glColor3f(0.1,0,0.1);
glTranslatef(0,0,0.1);
glRotatef(90,1,0,0);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0,0.0,0.0);
for(angle=0.0f; angle<((2.0f*Pi)+(Pi/32.0f)); angle+=(Pi/32.0f))
{
glVertex3f((1.0)*sin(angle),0.0,(1.0)*cos(angle));
}
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0,0.0,0.0);
for(angle=0.0f; angle<((2.0f*Pi)+(Pi/32.0f)); angle+=(Pi/32.0f))
{
glVertex3f((1.0)*sin(angle),0.5,(1.0)*cos(angle));
}
glEnd();
glPopMatrix();
// uchwyt - gałka
glPushMatrix();
glColor3f(0.1,0,0.1);
glTranslatef(0,0,0.5);
glScalef(1.75,0.5,0.5);
glutSolidCube(1);
glPopMatrix();
glPopMatrix();
//-----------------------------------------------//
// bolece
// wkrecanko - wykrecanko
glPushMatrix();
glTranslatef(bolce,0,0);
//--------//
//bolec górny
glPushMatrix();
glColor3f(0.6,0.6,0.7);
glTranslatef(2.75,1.5,0);
glScalef(2.0,1.25,0.5);
glutSolidCube(1);
glPopMatrix();
//bolec dolny
glPushMatrix();
glColor3f(0.6,0.6,0.7);
glTranslatef(2.75,-1.5,0);
glScalef(2.0,1.25,0.5);
glutSolidCube(1);
glPopMatrix();
glPopMatrix();
//--------------------------------------------//
glPopMatrix();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void UstawParametryWidoku(int szer, int wys)
{
// Zapamietanie wielkosci widoku
szerokoscOkna = szer;
wysokoscOkna = wys;
// Ustawienie parametrow viewportu
glViewport(0, 0, szerokoscOkna, wysokoscOkna);
// Przejscie w tryb modyfikacji macierzy rzutowania
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja wyswietlajaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
// Wyczyszczenie bufora koloru i bufora glebokosci
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
glMatrixMode(GL_MODELVIEW);
// Zastapienie aktywnej macierzy macierza jednostkowa
glLoadIdentity();
// Ustalenie polozenia obserwatora
glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);
// Narysowanie szescianu
RysujZamek();
// Przelaczenie buforow ramki
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
if (klawisz == 'z')
OBSERWATOR_OBROT_X +=3;
else if (klawisz == 'c')
OBSERWATOR_OBROT_Y +=3;
else if (klawisz == 'a')
OBSERWATOR_OBROT_X -=3;
else if (klawisz == 'v')
OBSERWATOR_OBROT_Y -=3;
else if (klawisz == '-')
OBSERWATOR_ODLEGLOSC +=3;
else if (klawisz == '+')
OBSERWATOR_ODLEGLOSC -=3;
else if (klawisz == 'b')
OBSERWATOR_OBROT_Z +=3;
else if (klawisz == 'n')
OBSERWATOR_OBROT_Z -=3;
else if (klawisz == 'd')
{ if(krec<15)
{krec ++;}
if(bolce>-0.75)
{bolce -=0.05;}
}
else if (klawisz == 'f')
{if(krec>-25)
{krec --;}
if(bolce<1.25)
{ bolce +=0.05;}
}
/* else if (klawisz == 'g')
{bolce --;}
else if (klawisz == 'h')
{ bolce ++;}
else if (klawisz == 's')
{blk--;}
else if (klawisz == 'd')
{if(blk<1) blk++;}
else if (klawisz == 'j')
{bpk--;}
else if (klawisz == 'h')
{if(bpk<1) bpk++;}
*/
else if (klawisz == 27)
exit(0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Glowna funkcja programu
int main(int argc, char **argv)
{
// Zainicjowanie biblioteki GLUT
glutInit(&argc, argv);
// Ustawienie trybu wyswietlania
glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
// Ustawienie polozenia dolenego lewego rogu okna
glutInitWindowPosition(100, 100);
// Ustawienie rozmiarow okna
glutInitWindowSize(szerokoscOkna, wysokoscOkna);
// Utworzenie okna
glutCreateWindow("Zamek GERDA by grigor");
// Odblokowanie bufora glebokosci
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_FILL);
// Zarejestrowanie funkcji (callback) odpowiedzialnej za
glutDisplayFunc(WyswietlObraz);
// Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
// zmieniane sa rozmiary okna
glutReshapeFunc(UstawParametryWidoku);
// Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
// zadnych zadan
glutIdleFunc(WyswietlObraz);
// Zarejestrowanie funkcji obslugi klawiatury
glutKeyboardFunc(ObslugaKlawiatury);
// Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
glutMainLoop();
return 0;
}
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
SAMOLOT
#include <GL/glut.h>
#include <math.h>
// Definicja stalych
float OBSERWATOR_ODLEGLOSC = 25.0;
float OBSERWATOR_OBROT_X = 0.0;
float OBSERWATOR_OBROT_Y = 0.0;
float OBSERWATOR_OBROT_Z = 0.0;
#define OBSERWATOR_FOV_Y 30.0
float t = 30;
// Zmienne globalne
int szerokoscOkna = 1000;
int wysokoscOkna = 600;
GLfloat smiglo;
float zzz=5; // DZIEKI TEMU LATA :D
// Prototypy funkcji
void RysujRakiete();
void rys();
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).
void RysujRakiete()
{
glPushMatrix();
glRotatef(150,0,1,0); // (kat obrotu, x,y,z) wokol ktorej osi obrot
glTranslatef(0,0,zzz);
//glTranslatef(0.0, 0.0, -5.0);
// kokpit rakiety//
glPushMatrix();
GLUquadricObj *trzon; // funkcja rysujaca kwadryki
trzon=gluNewQuadric();
glColor3f(1,1,1);
gluCylinder(trzon,0.75,0.75,10.0,15,15); // (wskaznik, promien mniejszy, promien wiekszy, dlugosc, ilosc podzialek poludnikow, rownoleznikow)
gluDeleteQuadric(trzon);
glPopMatrix();
// czubek- podstawa dla smigla//
glPushMatrix();
glutWireSphere(0.75,13,13); // (promien, poludniki, rownolezniki)
glPopMatrix();
//smiglo//
glPushMatrix();
glColor3f(1,1,1);
glRotatef(smiglo,0,0,1); //2. obrot o alfa wzdluz z
glTranslatef(0,0,-0.875); //3. w smigielku jest srodek
glScalef(16,1,1); //4. 16*0,25=4
glutWireCube(0.25); //1. sześcian
smiglo+=t; // predkosc
glPopMatrix();
//skrzydlo tylne pionowe
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(0.0,1.75,9.25); //2.
glScalef(1.0,8.0,6.0); //3.
glutWireCube(0.25); //1.
glPopMatrix();
//skrzydlo tylne poziome 1
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(2.0,0.0,9.25); // 2.
glScalef(10.0,1.0,6.0); //3.
glutWireCube(0.25); //1. szczescian
glPopMatrix();
// skrzydlo tylne poziome 2
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(-2.0,0.0,9.25);
glScalef(10.0,1.0,6.0);
glutWireCube(0.25);
glPopMatrix();
//glowny plat skrzydlowy
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(0.0,0.625,5.0); //2.
glScalef(32.0,1.0,12.0); //3.
glutWireCube(0.25); //1.
glPopMatrix();
glPopMatrix();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void UstawParametryWidoku(int szer, int wys)
{
// Zapamietanie wielkosci widoku
szerokoscOkna = szer;
wysokoscOkna = wys;
// Ustawienie parametrow viewportu
glViewport(0, 0, szerokoscOkna, wysokoscOkna);
// Przejscie w tryb modyfikacji macierzy rzutowania
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja wyswietlajaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
// Wyczyszczenie bufora koloru i bufora glebokosci
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
glMatrixMode(GL_MODELVIEW);
// Zastapienie aktywnej macierzy macierza jednostkowa
glLoadIdentity();
// Ustalenie polozenia obserwatora
glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);
// Narysowanie szescianu
RysujRakiete();
// Przelaczenie buforow ramki
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
if (klawisz == 'x')
OBSERWATOR_OBROT_X ++;
else if (klawisz == 'c')
OBSERWATOR_OBROT_Y ++;
else if (klawisz == 'z')
OBSERWATOR_OBROT_X --;
else if (klawisz == 'v')
OBSERWATOR_OBROT_Y --;
else if (klawisz == '-')
OBSERWATOR_ODLEGLOSC ++;
else if (klawisz == '+')
OBSERWATOR_ODLEGLOSC --;
else if (klawisz == 'b')
OBSERWATOR_OBROT_Z ++;
else if (klawisz == 'n')
OBSERWATOR_OBROT_Z --;
else if (klawisz == 'm')
zzz --;
else if (klawisz == ',')
zzz ++;
else if (klawisz == 27)
exit(0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Glowna funkcja programu
int main(int argc, char **argv)
{
// Zainicjowanie biblioteki GLUT
glutInit(&argc, argv);
// Ustawienie trybu wyswietlania
glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
// Ustawienie polozenia dolenego lewego rogu okna
glutInitWindowPosition(100, 100);
// Ustawienie rozmiarow okna
glutInitWindowSize(szerokoscOkna, wysokoscOkna);
// Utworzenie okna
glutCreateWindow("Rakieta");
// Odblokowanie bufora glebokosci
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
glutDisplayFunc(WyswietlObraz);
// Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
// zmieniane sa rozmiary okna
glutReshapeFunc(UstawParametryWidoku);
// Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
// zadnych zadan
glutIdleFunc(WyswietlObraz);
// Zarejestrowanie funkcji obslugi klawiatury
glutKeyboardFunc(ObslugaKlawiatury);
// Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
glutMainLoop();
return 0;
}
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
KRAN
//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#include <GL/glut.h>
#include <math.h>
// Definicja stalych
float OBSERWATOR_ODLEGLOSC = 40.0;
float OBSERWATOR_OBROT_X =10.0;
float OBSERWATOR_OBROT_Y =30.0;
float OBSERWATOR_OBROT_Z =0.0;
#define OBSERWATOR_FOV_Y 20.0
#define R 1
// Zmienne globalne
int szerokoscOkna = 800;
int wysokoscOkna = 600;
float obr_kran = 0.0;
float obr_kurek_poziom = 0.0;
float obr_kurek_pion = 0.0;
float p_poz=25;
// Prototypy funkcji
void RysujBateria();
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).
void RysujBateria()
{
float x, z, fi, skok_poz;
const long double PI = 3.1415926535897932384626433832795028841971693993751058209;
skok_poz = PI/p_poz;
glPushMatrix();
//podstawa
glPushMatrix();
glTranslatef(0,-5,0);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0, 0.0, 0.0);
for(fi = 0; fi <= 2.0001*PI; fi += skok_poz)
{
x = R * cos(fi);
z = R * sin(fi);
glVertex3f(x, 0, z);
}
glEnd();
glPopMatrix();
// pionowy walec dol
glPushMatrix();
glColor3f(0,0,1);
GLUquadricObj *trzon;
trzon=gluNewQuadric();
glTranslatef(0,0,0);
glRotatef(90,1,0,0);
gluCylinder(trzon,0.75,0.75,5,20,15);
gluDeleteQuadric(trzon);
glPopMatrix();
// pionowy walec srodek
glPushMatrix();
glRotatef(obr_kran,0,1,0);
glPushMatrix();
glColor3f(1,0,1);
GLUquadricObj *sr;
sr=gluNewQuadric();
glTranslatef(0,3,0);
glRotatef(90,1,0,0);
gluCylinder(sr,0.75,0.75,3,20,15);
gluDeleteQuadric(sr);
glPopMatrix();
// kran
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(0,2,2.25);
glScalef(0.6,0.6,3.0);
glutWireCube(1);
glPopMatrix();
// fiutrk od kranu
glPushMatrix();
glColor3f(0,1,0);
GLUquadricObj *fu;
fu=gluNewQuadric();
glTranslatef(0,1.75,3);
glRotatef(45,1,0,0);
gluCylinder(fu,0.15,0.15,0.5,20,15);
gluDeleteQuadric(fu);
glPopMatrix();
glPopMatrix();
glPushMatrix();
glTranslatef(0,3,0);
glRotatef(obr_kurek_poziom,0,1,0);
glRotatef(obr_kurek_pion, 1,0,0);
// pionowy kula gora
glPushMatrix();
glColor3f(1,0,0);
// glTranslatef(0,3,0);
glRotatef(90,1,0,0);
glutWireSphere(0.75,20,20);
glPopMatrix();
// kurek do krecenia
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(0,0.3,1.6);
glScalef(0.3,0.3,2.0);
glutWireCube(1);
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void UstawParametryWidoku(int szer, int wys)
{
// Zapamietanie wielkosci widoku
szerokoscOkna = szer;
wysokoscOkna = wys;
// Ustawienie parametrow viewportu
glViewport(0, 0, szerokoscOkna, wysokoscOkna);
// Przejscie w tryb modyfikacji macierzy rzutowania
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja wyswietlajaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
// Wyczyszczenie bufora koloru i bufora glebokosci
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
glMatrixMode(GL_MODELVIEW);
// Zastapienie aktywnej macierzy macierza jednostkowa
glLoadIdentity();
// Ustalenie polozenia obserwatora
glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);
// Narysowanie szescianu
RysujBateria();
// Przelaczenie buforow ramki
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
if (klawisz == 'x')
OBSERWATOR_OBROT_X ++;
else if (klawisz == 'c')
OBSERWATOR_OBROT_Y ++;
else if (klawisz == 'z')
OBSERWATOR_OBROT_X --;
else if (klawisz == 'v')
OBSERWATOR_OBROT_Y --;
else if (klawisz == '-')
OBSERWATOR_ODLEGLOSC ++;
else if (klawisz == '+')
OBSERWATOR_ODLEGLOSC --;
else if (klawisz == 'b')
OBSERWATOR_OBROT_Z ++;
else if (klawisz == 'n')
OBSERWATOR_OBROT_Z --;
else if (klawisz == 'g'){
if (obr_kran<40)
obr_kran ++;}
else if (klawisz == 'f'){
if (obr_kran>-40)
obr_kran --;}
else if (klawisz == 'j'){
if (obr_kurek_poziom>-20)
obr_kurek_poziom --;}
else if (klawisz == 'l'){
if (obr_kurek_poziom<20)
obr_kurek_poziom ++;}
else if (klawisz == 'k'){
if (obr_kurek_pion<4)
obr_kurek_pion ++;}
else if (klawisz == 'i'){
if (obr_kurek_pion>-20)
obr_kurek_pion --; }
else if (klawisz == 27)
exit(0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Glowna funkcja programu
int main(int argc, char **argv)
{
// Zainicjowanie biblioteki GLUT
glutInit(&argc, argv);
// Ustawienie trybu wyswietlania
glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
// Ustawienie polozenia dolenego lewego rogu okna
glutInitWindowPosition(100, 100);
// Ustawienie rozmiarow okna
glutInitWindowSize(szerokoscOkna, wysokoscOkna);
// Utworzenie okna
glutCreateWindow("Bateria");
// Odblokowanie bufora glebokosci
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
glutDisplayFunc(WyswietlObraz);
// Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
// zmieniane sa rozmiary okna
glutReshapeFunc(UstawParametryWidoku);
// Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
// zadnych zadan
glutIdleFunc(WyswietlObraz);
// Zarejestrowanie funkcji obslugi klawiatury
glutKeyboardFunc(ObslugaKlawiatury);
// Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
glutMainLoop();
return 0;
}
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
LAMPKA
//////////////////////////////////////////////////////////////////////////////////////////
//
// Program wyswietlajacy szescian w rzucie perspektywicznym. Dlugosc boku szescianu
// moze byc interaktywnie zmieniana za pomoca klwiszy '+' i '-'.
//
//////////////////////////////////////////////////////////////////////////////////////////
#include <GL/glut.h>
#include <math.h>
// Definicja stalych
float OBSERWATOR_ODLEGLOSC = 25.0;
float OBSERWATOR_OBROT_X =10.0;
float OBSERWATOR_OBROT_Y =10.0;
float OBSERWATOR_OBROT_Z =0.0;
#define OBSERWATOR_FOV_Y 40.0
// Zmienne globalne
int szerokoscOkna = 1000;
int wysokoscOkna = 600;
float zzz=0;
double obr_w_prawo = 0.0;
double obr_w_lewo = 0.0;
// Prototypy funkcji
void RysujLampke();
void UstawParametryWidoku(int szer, int wys);
void WyswietlObraz(void);
void ObslugaKlawiatury(unsigned char klawisz, int x, int y);
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca szescian o boku "a" w trybie GL_QUAD_STRIP.
// Srodek szescianu znajduje się w punkcie (0,0,0).
void RysujLampke()
{
glPushMatrix();
/* glPushMatrix();
glutWireSphere(3.0,40.0,30.0);
//(promien, ilosc poludnikow,ilosc rownoleznikow)
glPopMatrix();
*/
// podstawa
glPushMatrix(); // odklada na stos
GLUquadricObj *trzon;
trzon=gluNewQuadric();
glColor3f(1,0,0); // (R,G,B)
glTranslatef(0.0,0.5,0.0); // ustawia sie polozenie (tu podwyzszasz) (x,y,z)
glRotatef(90.0,1,0,0); // obrot (kat,x,y,z) x,y,z <-- ktoras musi byc 1, wtedy bedzie obracac wg osi
gluCylinder(trzon,2.5,2.5,0.5,20,15); // (wskazink,peomin podstawy, promien wyzszy, wysokosc, siatki (podzialy, pionowe i poziome)
gluDeleteQuadric(trzon); // zwalnia pamiec
glPopMatrix();
//czpien
glPushMatrix();
glColor3f(1,1,1);
glTranslatef(0,3,0); // przesunac zeby lezal gdzie trzeba
glScalef(1,10,1); // skracanie badz wydluzanie bokow (x,y,z) [mnozenie tego co jest w glutWireCube]
glRotatef(obr_w_prawo,0,1,0); // obrot w osoi y (x,y,z) //obr_w_prawo <-- o ile ma sie przekrecic (kat)
glutWireCube(0.5); // tworzy siatke szescianu o boku 0.5
/* obr_w_prawo+=2.0; */ // zeby samo sie krecilo
glPopMatrix();
//palag
glPushMatrix(); // ze zawsze zaczyna sie od srodka (0,0,0)
glRotatef(obr_w_prawo,0,1,0);
glTranslatef(0,5,0);
glRotated(obr_w_lewo,0,0,1);
glTranslatef(-1.5,0,0.375); // "-" bo w lewo, palag nie jest na srodku
// dopytac sie grzecha ocb z 0.375
glPushMatrix();
// glTranslatef(0,5,0);
//glTranslatef(0,0,0.375);
// glTranslatef(-1.5,0,0);
glScalef(20,1,1);
glutWireCube(0.25);
glPopMatrix();
//uchwyt abazura
glPushMatrix();
GLUquadricObj *uchwyt;
uchwyt=gluNewQuadric();
glColor3f(0,1,0);
glTranslatef(-2.75,0.5,0.0); // 0.5(pol wysokosci)
glRotatef(90,1,0,0); //obrot 90stopni w x
gluCylinder(uchwyt,0.25,0.25,1.0,20,15);
gluDeleteQuadric(uchwyt);
glPopMatrix();
// abazur
glPushMatrix();
GLUquadricObj *abazur;
abazur=gluNewQuadric();
glColor3f(1,0,1);
glTranslatef(-2.75,-0.5,0.0);
glRotatef(90.0,1,0,0);
gluCylinder(abazur,0.5,1.0,1.0,20,15);
gluDeleteQuadric(abazur);
glPopMatrix();
glPopMatrix();
glPopMatrix();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void UstawParametryWidoku(int szer, int wys)
{
// Zapamietanie wielkosci widoku
szerokoscOkna = szer;
wysokoscOkna = wys;
// Ustawienie parametrow viewportu
glViewport(0, 0, szerokoscOkna, wysokoscOkna);
// Przejscie w tryb modyfikacji macierzy rzutowania
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(OBSERWATOR_FOV_Y, (float)szerokoscOkna/(float)wysokoscOkna, 1.0, 1000.0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja wyswietlajaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
// Wyczyszczenie bufora koloru i bufora glebokosci
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
glMatrixMode(GL_MODELVIEW);
// Zastapienie aktywnej macierzy macierza jednostkowa
glLoadIdentity();
// Ustalenie polozenia obserwatora
glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);
// Narysowanie szescianu
RysujLampke();
// Przelaczenie buforow ramki
glutSwapBuffers();
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{
if (klawisz == 'x')
OBSERWATOR_OBROT_X ++;
else if (klawisz == 'c')
OBSERWATOR_OBROT_Y ++;
else if (klawisz == 'z')
OBSERWATOR_OBROT_X --;
else if (klawisz == 'v')
OBSERWATOR_OBROT_Y --;
else if (klawisz == '-')
OBSERWATOR_ODLEGLOSC ++;
else if (klawisz == '+')
OBSERWATOR_ODLEGLOSC --;
else if (klawisz == 'b')
OBSERWATOR_OBROT_Z ++;
else if (klawisz == 'n')
OBSERWATOR_OBROT_Z --;
else if (klawisz == 'm')
zzz --;
else if (klawisz == ',')
zzz ++;
else if (klawisz == 'h') // { if obr_w_prawo <180) obr_w_prawo++; }
obr_w_prawo++; // prawo, ale chodzi o to, ze w poziomie
else if (klawisz == 'j')
obr_w_prawo--;
else if (klawisz == 'g')
obr_w_lewo++;
else if (klawisz == 'd')
obr_w_lewo--;
else if (klawisz == 27)
exit(0);
}
//////////////////////////////////////////////////////////////////////////////////////////
// Glowna funkcja programu
int main(int argc, char **argv)
{
// Zainicjowanie biblioteki GLUT
glutInit(&argc, argv);
// Ustawienie trybu wyswietlania
glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
// Ustawienie polozenia dolenego lewego rogu okna
glutInitWindowPosition(100, 100);
// Ustawienie rozmiarow okna
glutInitWindowSize(szerokoscOkna, wysokoscOkna);
// Utworzenie okna
glutCreateWindow("Lampka Grzesia ;)");
// Odblokowanie bufora glebokosci
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
glutDisplayFunc(WyswietlObraz);
// Zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
// zmieniane sa rozmiary okna
glutReshapeFunc(UstawParametryWidoku);
// Zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
// zadnych zadan
glutIdleFunc(WyswietlObraz);
// Zarejestrowanie funkcji obslugi klawiatury
glutKeyboardFunc(ObslugaKlawiatury);
// Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
glutMainLoop();
return 0;
}
\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
WIATRAK
#include <GL/glut.h>
#include <math.h>
#define PI 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706710f
// zmienne globalne
float OBSERWATOR_ODLEGLOSC = 30.0;
float OBSERWATOR_OBROT_X = -50.0;
float OBSERWATOR_OBROT_Y = 0.0;
float OBSERWATOR_OBROT_Z = 20.0;
float OBSERWATOR_FOV_Y = 30.0;
int windowWidth = 800;
int windowHeight = 600;
bool powrot = 0;
float i, j,
x, y, z, kat, r = 3.0;
// prototypy funkcji
//void DrawFigure();
void ViewParameter(int width, int height);
void Display(void);
void Keyboard(unsigned char klawisz, int x, int y);
// glowna funkcja programu
int main(int argc, char **argv)
{
// zainicjowanie biblioteki GLUT
glutInit(&argc, argv);
// ustawienie trybu wyswietlania
glutInitDisplayMode (GLUT_DOUBLE|GLUT_RGB|GLUT_DEPTH);
// ustawienie polozenia dolenego lewego rogu okna
glutInitWindowPosition(100, 100);
// ustawienie rozmiarow okna
glutInitWindowSize(windowWidth, windowHeight);
// utworzenie okna
glutCreateWindow("figurka by PAUL\0");
// odblokowanie bufora glebokosci
glEnable(GL_DEPTH_TEST);
// ustawienie wartosci czyszczacej zawartosc bufora glebokosci
glClearDepth(1000.0);
// ustawienie koloru czyszczenia bufora ramki
glClearColor (0.2f, 0.5f, 0.25f, 0.0f);
// wlaczenie wyswietlania wielokatow w postaci obrysow (przydatne w celach diagnostycznych).
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// Zarejestrowanie funkcji (callback) odpowiedzialnej za
glutDisplayFunc(Display);
// zarejestrowanie funkcji (callback) wywolywanej za kazdym razem kiedy
// zmieniane sa rozmiary okna
glutReshapeFunc(ViewParameter);
// zarejestrowanie funkcji wykonywanej gdy okno nie obsluguje
// zadnych zadan
glutIdleFunc(Display);
// zarejestrowanie funkcji obslugi klawiatury
glutKeyboardFunc(Keyboard);
// obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
glutMainLoop();
return 0;
}
// funkcja rysujaca figure
void wow()
{
const double t = glutGet(GLUT_ELAPSED_TIME) / 2000.0;
const double a = t*60.0;
glColor3f(111.0/256.0, 66.0/256.0, 17.0/256.0);
glBegin(GL_QUAD_STRIP);
glVertex3f(1.0, 1.0, 0.0);
glVertex3f(1.0, 1.0, 6.0);
glVertex3f(1.0, -1.0, 0.0);
glVertex3f(1.0, -1.0, 6.0);
glVertex3f(-1.0, -1.0, 0.0);
glVertex3f(-1.0, -1.0, 6.0);
glVertex3f(-1.0, 1.0, 0.0);
glVertex3f(-1.0, 1.0, 6.0);
glVertex3f(1.0, 1.0, 0.0);
glVertex3f(1.0, 1.0, 6.0);
glEnd();
glColor3f(98.0/256.0, 58.0/256.0, 15.0/256);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0.0 ,0.0, 8.0);
glVertex3f(1.0, 1.0, 6.0);
glVertex3f(1.0, -1.0, 6.0);
glVertex3f(-1.0, -1.0, 6.0);
glVertex3f(-1.0, 1.0, 6.0);
glVertex3f(1.0, 1.0, 6.0);
glEnd();
glPushMatrix();
glTranslated(0, -1.1, 5);
glRotated(90, 1, 0, 0);
glRotated(a, 0, 0, 1);
for(i = 0, kat = PI/14.0; i < 14; i++, kat += PI/7.0)
{
glBegin(GL_TRIANGLES);
glColor3f(cos(kat), sin(kat), (cos(kat)+sin(kat)) / 2.0);
glVertex2f(0.0, 0.0);
glColor3f(cos(kat), (cos(kat)+sin(kat)) / 2.0, sin(kat));
glVertex2f(r*cos(kat), r*sin(kat));
glColor3f((cos(kat)+sin(kat)) / 2.0, sin(kat), cos(kat));
glVertex2f(r*cos(kat+PI/14.0), r*sin(kat+PI/14.0));
glEnd();
}
glPopMatrix();
}
//void DrawFigure()
//{
// wow();
//}
// funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu. Powinna
// być wywolywana kazdorazowo po zmianie rozmiarow okna programu.
void ViewParameter(int width, int height)
{
// zapamietanie wielkosci widoku
windowWidth = width;
windowHeight = height;
// ustawienie parametrow viewportu
glViewport(0, 0, windowWidth, windowHeight);
// przejscie w tryb modyfikacji macierzy rzutowania
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(OBSERWATOR_FOV_Y, (float)windowWidth/(float)windowHeight, 1.0, 1000.0);
}
// funkcja wyswietlajaca pojedyncza klatke animacji
void Display(void)
{
// wyczyszczenie bufora koloru i bufora glebokosci
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
// przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
glMatrixMode(GL_MODELVIEW);
// zastapienie aktywnej macierzy macierza jednostkowa
glLoadIdentity();
// ustalenie polozenia obserwatora
glTranslatef(0, 0, -OBSERWATOR_ODLEGLOSC);
glRotatef(OBSERWATOR_OBROT_X, 1, 0, 0);
glRotatef(OBSERWATOR_OBROT_Y, 0, 1, 0);
glRotatef(OBSERWATOR_OBROT_Z, 0, 0, 1);
// narysowanie szescianu
wow();
// przelaczenie buforow ramki
glutSwapBuffers();
}
// funkcja obslugi klawiatury
void Keyboard(unsigned char klawisz, int x, int y)
{
if (klawisz == 'q')
OBSERWATOR_OBROT_X -= 2.0; // obrót wokoł osi X w gore
else if(klawisz == 'w')
OBSERWATOR_OBROT_X += 2.0; // obrót wokoł osi X w dol
else if (klawisz == 'a')
OBSERWATOR_OBROT_Y -= 2.0; // obrót wokoł osi Y w gore
else if(klawisz == 's')
OBSERWATOR_OBROT_Y += 2.0; // obrót wokoł osi Y w dol
else if (klawisz == 'z')
OBSERWATOR_OBROT_Z -= 2.0; // obrót wokoł osi Z w gore
else if(klawisz == 'x')
OBSERWATOR_OBROT_Z += 2.0; // obrót wokoł osi Z w dol
else if (klawisz == 'e')
OBSERWATOR_ODLEGLOSC -= 2.0; // Przybliżenie
else if(klawisz == 'd')
OBSERWATOR_ODLEGLOSC += 2.0; // Oddalenie
else if (klawisz == 27)
exit(0);
}