wiatrak full

//////////////////////////////////////////////////////////////////////////////////////////
// Program demonstruje  skladanie transformacji przy modelowaniu zlozonych obiektow
// skladajacych sie z wielu elementow ruchomych (ramie robota).

#include "glut.h"


// Wskazniki do wykorzystywanych kwadryk
GLUquadricObj* podstawaSciany;
GLUquadricObj* podstawaDyskG;
GLUquadricObj* przegubSciany;
GLUquadricObj* przegubDyskG;
GLUquadricObj* przegubDyskD;
GLUquadricObj* glowicaSciany;
GLUquadricObj* glowicaDyskG;
GLUquadricObj* glowicaDyskD;

// rakieta
GLUquadricObj* srodek;
GLfloat rotRakiety = 0.0;
GLfloat rotRakiety2 = 0.0;
GLfloat rotRakiety22 = 0.0;

// Zadanie 2
GLUquadricObj* orb;
GLfloat rotPlanety1 = 0.0;
GLfloat spinPlanety1 = 0.0;
GLfloat rotKsiezyca = 0.0;

GLfloat rotPlanety2 = 0.0;
GLfloat rotPlanety3 = 0.0;

GLfloat rotObsY = 40.0;
GLfloat rotObsX = 40.0;
GLfloat rotObsZ = 0.0;

GLfloat rotPodstawy = 0.0;
GLfloat rotRamienia1 = 40.0;
GLfloat rotRamienia2 = -40.0;
GLfloat rotGlowicy = 20.0;
GLfloat rozUchwytow = 0.5;
int alfa = 0;

GLfloat odlobs = -250.0;
GLfloat odlmin = 0.0;
GLfloat odlmax = -500;
int frame = 0;

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja inicjujaca elementy skladowe ramienia robota zamodelowane jako kwadryki
//
void InicjujRamieRobota(void)
{
	// Zainicjowanie scian bocznych walca bedacego podstawa ramienia
	podstawaSciany = gluNewQuadric();
	gluQuadricDrawStyle(podstawaSciany, GLU_FILL);

	// Zainicjowanie gornej podstawy walca
	podstawaDyskG = gluNewQuadric();
	gluQuadricDrawStyle(podstawaDyskG, GLU_LINE);

	// Zainicjowanie scian bocznych cylindrycznego przegubu ramienia
	przegubSciany = gluNewQuadric();
	gluQuadricDrawStyle(przegubSciany, GLU_LINE);

	// Zainicjowanie gornej podstawy walca
	przegubDyskG = gluNewQuadric();
	gluQuadricDrawStyle(przegubDyskG, GLU_LINE);

	// Zainicjowanie dolnej podstawy walca
	przegubDyskD = gluNewQuadric();
	gluQuadricDrawStyle(przegubDyskD, GLU_LINE);

	// Zainicjowanie scian bocznych cylindra glowicy
	glowicaSciany = gluNewQuadric();
	gluQuadricDrawStyle(glowicaSciany, GLU_LINE);

	// Zainicjowanie gornej podstawy walca
	glowicaDyskG = gluNewQuadric();
	gluQuadricDrawStyle(glowicaDyskG, GLU_LINE);

	// Zainicjowanie dolnej podstawy walca
	glowicaDyskD = gluNewQuadric();
	gluQuadricDrawStyle(glowicaDyskD, GLU_LINE);

}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja rysujaca obraz sceny widzianej z biezacej pozycji obserwatora
// Zalozenie: Funkcja glutWireSpehere moze ryswac tylko sfere o promieniu 1
void RysujRamieRobota(GLfloat obrotPodstawy, GLfloat obrotRamienia1,
	GLfloat obrotRamienia2, GLfloat obrotGlowicy,
	GLfloat rozstawUchwytow)
{
	// Pocztaek tworzenia ukladu wspolrzednych
	glBegin(GL_LINES);

	// Os X
	glColor3f(1.0, 0.0, 0.0);
	glVertex3f(-140.0, 0.0, 0.0);
	glVertex3f(140.0, 0.0, 0.0);

	// Os Y
	glColor3f(0.0, 1.0, 0.0);
	glVertex3f(0.0, -120.0, 0.0);
	glVertex3f(0.0, 120.0, 0.0);

	// Os Z
	glColor3f(0.0, 0.0, 1.0);
	glVertex3f(0.0, 0.0, -120.0);
	glVertex3f(0.0, 0.0, 120.0);

	// Koniec tworzenia ukladu wspolrzednych
	glEnd();


	glColor3f(1.0, 1.0, 0.0);

	glPushMatrix();
	glTranslatef(50, 0.0, 0.0);

	// Przygotowanie stosu macierzy modelowania
	glPushMatrix();

	// Rysowanie podstawy ramienia (cylinder bez dolnej podstawy)
	glPushMatrix();
	// - sciany boczne
	glRotatef(-90.0, 1, 0, 0);
	gluCylinder(podstawaSciany, 3.0, 3.0, 1.0, 20, 4);

	// - gorna podstawa
	glTranslatef(0.0, 0.0, 1.0);
	gluDisk(podstawaDyskG, 0.0, 3.0, 20, 4);
	glPopMatrix();


	// Rysowanie dwoch wspornikow ramienia (prostopadlosciany)
	glPushMatrix();
	glScalef(3.0, 4.0, 1.0);
	glTranslatef(0.0, 3.0 / 4.0, 1.0);
	glutWireCube(1);
	glTranslatef(0.0, 0.0, -2.0);
	glutWireCube(1);
	glPopMatrix();

	// Wyznaczenie osi obrotu ramienia w plaszczyznie pionowej
	glTranslatef(0.0, 4.0, 0.0);

	// Obrot ramienia w plaszczyznie pionowej
	glRotatef(obrotRamienia1, 0, 0, 1);

	// Modelowanie ramienia nr 1
	glPushMatrix();
	glScalef(8.0, 1.0, 1.0);
	glTranslatef(3.5 / 8.0, 0.0, 0.0);
	glutWireCube(1);
	glPopMatrix();

	// Wyznaczenie osi obrotu ramienia 2 w plaszczyznie pionowej
	glTranslatef(7.5, 0.0, 0.0);

	// Obrot ramienia 2 wzgledem ramienia 1
	glRotatef(obrotRamienia2, 0, 0, 1);

	// Modelowanie przegubu (walca z obiema podstawami)
	glPushMatrix();
	// - sciany boczne
	glTranslatef(0.0, 0.0, -0.5);
	gluCylinder(podstawaSciany, 1.0, 1.0, 1.0, 20, 4);

	// - gorna podstawa
	gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);

	// - dolna podstawa
	glTranslatef(0.0, 0.0, 1.0);
	gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
	glPopMatrix();

	// Modelowanie ramienia nr 2
	glPushMatrix();
	glScalef(4.0, 1.0, 1.0);
	glTranslatef(2.0 / 4.0, 0.0, 0.0);
	glutWireCube(1);
	glPopMatrix();

	// Wyznaczenie osi obrotu glowicy
	glTranslatef(4.0, 0.0, 0.0);
	glRotatef(90, 0, 1, 0);
	glRotatef(obrotGlowicy, 0, 0, 1);

	// Modelowanie glowicy (walca z oboma podstawami)
	glPushMatrix();
	// - sciany boczne
	gluCylinder(podstawaSciany, 1.0, 1.0, 1.0, 20, 4);

	// - gorna podstawa
	gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);

	// - dolna podstawa
	glTranslatef(0.0, 0.0, 1.0);
	gluDisk(podstawaDyskG, 0.0, 1.0, 20, 4);
	glPopMatrix();

	// Modelowanie uchwytu (dwoch prostopadloscianow, ktore sie rozsuwaja i zsuwaja)
	glTranslatef(0.0, 0.0, 1.5);
	glScalef(0.5, 0.5, 2.0);
	glTranslatef(-rozstawUchwytow, 0.0, 0.25);
	glutWireCube(1);
	glTranslatef(rozstawUchwytow * 2.0, 0.0, 0.0);
	glutWireCube(1);



	// Posprzatanie na stosie macierzy modelowania
	glPopMatrix();
	glPopMatrix();
}

void RysujZadanie1()
{
	glPushMatrix();
	glTranslatef(80, 0, 0);

	//podstawa wiezy
	glPushMatrix();
	glTranslatef(0.0, 5.0, 0.0);
	glScalef(4.23, 10.0, 4.23);
	glRotatef(45.0, 0.0, 1.0, 0.0);
	glColor3f(1.0, 0.0, 0.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//szczyt wiezy
	glPushMatrix();
	glTranslatef(0.0, 11.5, 0.0);
	glScalef(8.0, 3.0, 8.0);
	glColor3f(0.0, 1.0, 0.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 1
	glPushMatrix();
	glTranslatef(3.0, 14.0, 3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 2
	glPushMatrix();
	glTranslatef(-3.0, 14.0, -3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 3
	glPushMatrix();
	glTranslatef(3.0, 14.0, -3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 4
	glPushMatrix();
	glTranslatef(-3.0, 14.0, 3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	glPopMatrix();
}


void RysujZadanie2()
{

	glPushMatrix();
	glTranslatef(0, 50, 0);
	orb = gluNewQuadric();
	gluQuadricDrawStyle(orb, GLU_LINE);

	// slonce i orbity
	glColor3f(1.0, 1.0, 0.0);
	glPushMatrix();

	glRotatef(90.0, 1, 0, 0);
	glRotatef(-90.0, 1.0, 0.0, 0.0);
	glPopMatrix();

	glColor3f(1.0, 1.0, 0.0);
	glPushMatrix();

	glRotatef(90.0, 1, 0, 0);
	gluDisk(orb, 20, 20, 100.0, 100); // orbita planet 1
	gluDisk(orb, 12, 12, 100.0, 100); // orbita planet 2
	gluDisk(orb, 40, 40, 100.0, 100); // orbita planet 3
	glScalef(5.0, 5.0, 5.0);
	glutWireSphere(1.0, 20.0, 20.0);
	glRotatef(-90, 1, 0, 0);
	glPopMatrix();


	//pierwsza planeta i ksiezyc
	glPushMatrix();

	glColor3f(1.0, 0.0, 0.0);
	glRotatef(rotPlanety1, 0.0, 1.0, 0.0);
	glTranslatef(0.0, 0.0, 20.0);
	glPushMatrix();

	glRotatef(spinPlanety1, 0.0, 1.0, 0.0);
	glRotatef(-90, 1, 0, 0);
	gluDisk(orb, 5.0, 5.0, 100, 100);
	glRotatef(-90, 1, 0, 0);
	glutWireSphere(2.0, 20.0, 20.0);
	glPopMatrix();

	glColor3f(0.0, 0.0, 1.0);
	glRotatef(rotKsiezyca, 0.0, 1.0, 0.0);
	glTranslatef(5.0, 0.0, 0.0);
	glScalef(0.5, 0.5, 0.5);
	glutWireSphere(1.0, 20.0, 20.0);

	glPopMatrix();

	// druga planeta bez ksiezyca
	glPushMatrix();

	glColor3f(1.0, 0.0, 0.0);
	glRotatef(rotPlanety2, 0.0, 1.0, 0.0);
	glTranslatef(0.0, 0.0, 12.0); // promien orbity 12
	glutWireSphere(3.0, 20.0, 20.0); // promien planety 3

	glPopMatrix();


	// trzecia planeta bez ksiezyca
	glPushMatrix();

	glColor3f(1.0, 0.0, 0.0);
	glRotatef(rotPlanety3, 0.0, 1.0, 0.0);
	glTranslatef(0.0, 0.0, 40.0); // promien orbity 12
	glutWireSphere(4.0, 20.0, 20.0); // promien planety 4

	glPopMatrix();

	glPopMatrix();


	rotPlanety1 -= 0.25; // CW
	spinPlanety1 += 1.0; // CCW
	rotKsiezyca += 0.5; // CCW

	rotPlanety2 += 0.15; // CCW
	rotPlanety3 -= 0.5; // CW
}

void RysujZadanie3()
{
	glPushMatrix();

	glPushMatrix();
	glRotatef(rotPlanety1, 0, 1, 0);
	glTranslatef(30, 0, 0);
	orb = gluNewQuadric();
	gluQuadricDrawStyle(orb, GLU_LINE);

	// slonce i orbity
	glColor3f(1.0, 1.0, 0.0);
	glPushMatrix();

	glRotatef(90.0, 1, 0, 0);
	glRotatef(-90.0, 1.0, 0.0, 0.0);
	glPopMatrix();

	glColor3f(1.0, 1.0, 0.0);
	glPushMatrix();

	glRotatef(90.0, 1, 0, 0);
	gluDisk(orb, 20, 20, 100.0, 100); // orbita planet 1
  //  gluDisk(orb, 12, 12, 100.0, 100); // orbita planet 2
//    gluDisk(orb, 40, 40, 100.0, 100); // orbita planet 3
	glScalef(5.0, 5.0, 5.0);
	glutWireSphere(1.0, 20.0, 20.0);
	glRotatef(-90, 1, 0, 0);
	glPopMatrix();


	//pierwsza planeta i ksiezyc
	glPushMatrix();

	glColor3f(1.0, 0.0, 0.0);
	glRotatef(rotPlanety1, 0.0, 1.0, 0.0);
	glTranslatef(0.0, 0.0, 20.0);
	glPushMatrix();

	glRotatef(spinPlanety1, 0.0, 1.0, 0.0);
	glRotatef(-90, 1, 0, 0);
	gluDisk(orb, 5.0, 5.0, 100, 100);
	glRotatef(-90, 1, 0, 0);
	glutWireSphere(2.0, 20.0, 20.0);
	glPopMatrix();


	glColor3f(0.0, 0.0, 1.0);
	glRotatef(rotKsiezyca, 0.0, 1.0, 0.0);
	glTranslatef(5.0, 0.0, 0.0);
	glScalef(0.5, 0.5, 0.5);
	glutWireSphere(1.0, 20.0, 20.0);
	glPopMatrix();
	glPopMatrix();

	// druga planeta bez ksiezyca
	//glPushMatrix();

	//glColor3f(1.0, 0.0, 0.0);
	//glRotatef(rotPlanety2, 0.0, 1.0, 0.0);
	//glTranslatef(0.0, 0.0, 12.0); // promien orbity 12
	//glutWireSphere(3.0, 20.0, 20.0); // promien planety 3

	//glPopMatrix();


	// trzecia planeta bez ksiezyca
	//glPushMatrix();

	//glColor3f(1.0, 0.0, 0.0);
	//glRotatef(rotPlanety3, 0.0, 1.0, 0.0);
	//glTranslatef(0.0, 0.0, 40.0); // promien orbity 12
	//glutWireSphere(4.0, 20.0, 20.0); // promien planety 4

	//glPopMatrix();

	//glPopMatrix();


	rotPlanety1 -= 0.25; // CW
	spinPlanety1 += 1.0; // CCW
	rotKsiezyca += 0.5; // CCW

	rotPlanety2 -= 0.15; // CCW
	rotPlanety3 -= 0.5; // CW


	glPushMatrix();
	glPushMatrix();
	glColor3f(0.5, 0.5, 0.5);
	glRotatef(90.0, 1, 0, 0);
	gluDisk(orb, 30, 30, 100.0, 100);
	glPopMatrix();
	glTranslatef(0, 0, 0);

	//podstawa wiezy
	glPushMatrix();
	glTranslatef(0.0, 5.0, 0.0);
	glScalef(4.23, 10.0, 4.23);
	glRotatef(45.0, 0.0, 1.0, 0.0);
	glColor3f(1.0, 0.0, 0.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//szczyt wiezy
	glPushMatrix();
	glTranslatef(0.0, 11.5, 0.0);
	glScalef(8.0, 3.0, 8.0);
	glColor3f(0.0, 1.0, 0.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 1
	glPushMatrix();
	glTranslatef(3.0, 14.0, 3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 2
	glPushMatrix();
	glTranslatef(-3.0, 14.0, -3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 3
	glPushMatrix();
	glTranslatef(3.0, 14.0, -3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	//maly szescian 4
	glPushMatrix();
	glTranslatef(-3.0, 14.0, 3.0);
	glScalef(2.0, 2.0, 2.0);
	glColor3f(0.0, 0.0, 1.0);
	glutSolidCube(1.0);
	glPopMatrix();

	glPopMatrix();

	glPopMatrix();
}


void RysujZadanie4()
{
	glBegin(GL_LINES);

	// Os X
	glColor3f(1.0, 0.0, 0.0);
	glVertex3f(-140.0, 0.0, 0.0);
	glVertex3f(140.0, 0.0, 0.0);

	// Os Y
	glColor3f(0.0, 1.0, 0.0);
	glVertex3f(0.0, -120.0, 0.0);
	glVertex3f(0.0, 120.0, 0.0);

	// Os Z
	glColor3f(0.0, 0.0, 1.0);
	glVertex3f(0.0, 0.0, -120.0);
	glVertex3f(0.0, 0.0, 120.0);

	// Koniec tworzenia ukladu wspolrzednych
	glEnd();



	rotPlanety1 -= 0.1; // CW


	orb = gluNewQuadric();
	// gluQuadricNormals(orb, GLU_SMOOTH);
	gluQuadricDrawStyle(orb, GLU_LINE);


	glPushMatrix();

		glPushMatrix();

		glRotatef(rotPlanety1, 0.0, 1.0, 0.0); // do wpisania obrotu

		// trzecie ramie
		glPushMatrix();
		glRotatef(240, 0.0, 1.0, 0.0);

		glPushMatrix();

		glTranslatef(0.0, 15.5, 45.0);
		glColor3f(1.0, 0.5, 0.5);
		glRotatef(90.0, 0.0, 1.0, 0.0);
		glScalef(50, 1, 12);
		glutSolidCube(1);

		glPopMatrix();



		glPushMatrix();

		glTranslatef(0.0, 15.0, 0.0);
		glColor3f(1.0, 0.5, 0.5);
		// glRotatef(90.0, 1.0, 0.0, 0.0);
		glScalef(2, 1, 1);
		gluCylinder(orb, 0.5, 0.5, 20, 100, 10);

		glPopMatrix();

		glPopMatrix();

		// drugie ramie
		glPushMatrix();
		glRotatef(120, 0.0, 1.0, 0.0);

		glPushMatrix();

		glTranslatef(0.0, 15.5, 45.0);
		glColor3f(1.0, 0.5, 0.5);
		glRotatef(90.0, 0.0, 1.0, 0.0);
		glScalef(50, 1, 12);
		glutSolidCube(1);

		glPopMatrix();



		glPushMatrix();

		glTranslatef(0.0, 15.0, 0.0);
		glColor3f(1.0, 0.5, 0.5);
		// glRotatef(90.0, 1.0, 0.0, 0.0);
		glScalef(2, 1, 1);
		gluCylinder(orb, 0.5, 0.5, 20, 100, 10);

		glPopMatrix();

		glPopMatrix();



			// pierwsze ramie
			glPushMatrix();


				glPushMatrix();

					glTranslatef(0.0, 15.5, 45.0);
					glColor3f(1.0, 0.5, 0.5);
					glRotatef(90.0, 0.0, 1.0, 0.0);
					glScalef(50, 1, 12);
					glutSolidCube(1);

				glPopMatrix();



				glPushMatrix();

					glTranslatef(0.0, 15.0, 0.0);
					glColor3f(1.0, 0.5, 0.5);
					// glRotatef(90.0, 1.0, 0.0, 0.0);
					glScalef(2, 1, 1);
					gluCylinder(orb, 0.5, 0.5, 20, 100, 10);

				glPopMatrix();

			glPopMatrix();

			// dolne wieczko dolnego cylindra
			glPushMatrix();

				glTranslatef(0.0, 10.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluDisk(orb, 0, 10, 100, 10);

			glPopMatrix();

			// dolny cylinder
			glPushMatrix();

				glTranslatef(0.0, 20.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluCylinder(orb, 10, 10, 10, 100, 10);

			glPopMatrix();

		glPopMatrix();

		glPushMatrix();

			// dolne wieczko srodkowego stozka
			glPushMatrix();

				glTranslatef(0.0, 20.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluDisk(orb, 0, 20, 100, 10);

			glPopMatrix();

			// gorne wieczko srodkowego cylindra
			glPushMatrix();

				glTranslatef(0.0, 30.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluDisk(orb, 0, 20, 100, 10);

			glPopMatrix();

			// srodkowy cylinder
			glPushMatrix();

				glTranslatef(0.0, 30.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluCylinder(orb, 20, 20, 10, 100, 10);

			glPopMatrix();

			// drazek z gornego stozka
			glPushMatrix();

				glTranslatef(0.0, 40.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluCylinder(orb, 2, 2, 10, 100, 10);

			glPopMatrix();

			//gorne wieczko gornego stozka
			glPushMatrix();

				glTranslatef(0.0, 40.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluDisk(orb, 0, 5, 100, 10);

			glPopMatrix();

			// dolne wieczko gornego stozka
			glPushMatrix();

				glTranslatef(0.0, 50.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluDisk(orb, 0, 10, 100, 10);

			glPopMatrix();

			// gorny stozek
			glPushMatrix();

				glTranslatef(0.0, 50.0, 0.0);
				glColor3f(1.0, 0.5, 0.5);
				glRotatef(90.0, 1.0, 0.0, 0.0);
				gluCylinder(orb, 10, 5, 10, 100, 10);

			glPopMatrix();

		glPopMatrix();

	glPopMatrix();
}


//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja generujaca pojedyncza klatke animacji
void WyswietlObraz(void)
{
	// Wyczyszczenie bufora ramki i bufora glebokosci
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Powielenie macierzy na wierzcholku stosu
	glPushMatrix();

	// Wyznaczenie polozenia obserwatora (przeksztalcenie uladu wspolrzednych
	// sceny do ukladu wspolrzednych obserwatora).
	glTranslatef(0, 0, odlobs);
	glRotatef(rotObsX, 1, 0, 0);
	glRotatef(rotObsY, 0, 1, 0);
	glRotatef(rotObsZ, 0, 0, 1);


	// Generacja obrazu sceny w niewidocznym buforze ramki

	//RysujRamieRobota(rotPodstawy, rotRamienia1, rotRamienia2, rotGlowicy, rozUchwytow);
	//RysujZadanie3();

	RysujZadanie4();

	// Usuniecie macierzy lezacej na  wierzcholku stosu (powrot do stanu
	// sprzed wywolania funkcji)
	glPopMatrix();

	// Przelaczenie buforow ramki
	glutSwapBuffers();



	glutPostRedisplay();


}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja ustawiajaca parametry rzutu perspektywicznego i rozmiary viewportu
void UstawParametryWidoku(int szerokosc, int wysokosc)
{
	// Ustawienie parametrow viewportu
	glViewport(0, 0, szerokosc, wysokosc);

	// Przejscie w tryb modyfikacji macierzy rzutowania
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	gluPerspective(40.0, (float)szerokosc / (float)wysokosc, 1.0, 1000.0);

	// Przejscie w tryb modyfikacji macierzy przeksztalcen geometrycznych
	glMatrixMode(GL_MODELVIEW);

	// Zmiana macierzy znajdujacej sie na wierzcholku stosu na macierz jednostkowa
	glLoadIdentity();
}

//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja klawiszy specjalnych
void ObslugaKlawiszySpecjalnych(int klawisz, int x, int y)
{
	switch (klawisz)
	{

	case GLUT_KEY_UP:
		rotObsX++;
		break;

	case GLUT_KEY_DOWN:
		rotObsX--;
		break;

	case GLUT_KEY_LEFT:
		rotObsY--;
		break;

	case GLUT_KEY_RIGHT:
		rotObsY++;
		break;


		// oblsuga klawiatury osi Z
	case GLUT_KEY_PAGE_DOWN:
		rotObsZ--;
		break;

	case GLUT_KEY_PAGE_UP:
		rotObsZ++;
		break;
	}
}
//////////////////////////////////////////////////////////////////////////////////////////
// Funkcja obslugi klawiatury
void ObslugaKlawiatury(unsigned char klawisz, int x, int y)
{

	switch (klawisz)
	{
	case '2':
		rotRamienia1 = (rotRamienia1 < 90.0) ? rotRamienia1 + 1.0 : rotRamienia1;
		break;

	case '@':
		rotRamienia1 = (rotRamienia1 > 0.0) ? rotRamienia1 - 1.0 : rotRamienia1;
		break;

	case '3':
		rotRamienia2 = (rotRamienia2 < 0.0) ? rotRamienia2 + 1.0 : rotRamienia2;
		break;

	case '#':
		rotRamienia2 = (rotRamienia2 > -90.0) ? rotRamienia2 - 1.0 : rotRamienia2;
		break;

	case '4':
		rotGlowicy = (rotGlowicy < 360.0) ? rotGlowicy + 1.0 : rotGlowicy;
		break;

	case '$':
		rotGlowicy = (rotGlowicy > 0.0) ? rotGlowicy - 1.0 : rotGlowicy;
		break;

	case '5':
		rozUchwytow = (rozUchwytow < 1.5) ? rozUchwytow + 0.1 : rozUchwytow;
		break;

	case '%':
		rozUchwytow = (rozUchwytow > 0.5) ? rozUchwytow - 0.1 : rozUchwytow;
		break;


		// obsluga klawiatury odleglosci uzytkownika od obiektow
	case '+':
		odlobs = (odlobs < odlmin) ? odlobs + 1.0 : odlobs;
		break;

	case '-':
		odlobs = (odlobs > odlmax) ? odlobs - 1.0 : odlobs;
		break;


		// rakieta
	case 'z':
		if (rotRakiety < 90) rotRakiety++;
		break;

	case 'x':
		if (rotRakiety > -90) rotRakiety--;
		break;

	case ',':
		if (rotRakiety2 < 5) rotRakiety2++;
		break;

	case '.':
		if (rotRakiety2 > 0) rotRakiety2--;
		break;

	}

	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(400, 400);

	// Utworzenie okna
	glutCreateWindow("Robot");

	// Odblokowanie bufora glebokosci
	glEnable(GL_DEPTH_TEST);

	// Ustawienie funkcji wykonywanej na danych w buforze glebokosci
	glDepthFunc(GL_LEQUAL);

	// Ustawienie wartosci czyszczacej zawartosc bufora glebokosci
	glClearDepth(1000.0);

	// Ustawienie koloru czyszczenia bufora ramki
	glClearColor(0.3, 0.3, 0.3, 0.0);

	// Zarejestrowanie funkcji (callback) wyswietlajacej
	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);

	// Zarejestrowanie funkcji obslugi klawiszy specjalnych
	glutSpecialFunc(ObslugaKlawiszySpecjalnych);


	// Zainicjowanie kwadryk tworzacych ramie robota
	InicjujRamieRobota();

	// Obsluga glownej petli programu (wywolywanie zarejestrowanych callbackow
	// w odpowiedzi na odbierane zdarzenia lub obsluga stanu bezczynnosci)
	glutMainLoop();

	return 0;
}