feat: new type of camera

fix: movement works like it should

Rover.cpp

@@ -0,0 +1 @@
+

fabula.cpp

@@ -0,0 +1,235 @@
+#include "fabula.hpp"
+
+
+std::vector<std::vector<bool>> wzory = {
+
+	// GK
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 1, 1, 1, 0, 1, 0, 0, 1, 0,
+	 0, 1, 0, 0, 0, 1, 0, 1, 1, 0,
+	 1, 1, 0, 0, 0, 1, 1, 1, 0, 0,
+	 1, 0, 0, 0, 0, 1, 1, 0, 0, 0,
+	 1, 0, 1, 1, 0, 1, 1, 0, 0, 0,
+	 1, 0, 0, 1, 1, 1, 1, 1, 0, 0,
+	 1, 1, 0, 0, 1, 1, 0, 1, 1, 0,
+	 0, 1, 1, 1, 1, 1, 0, 0, 1, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 1, 1},
+
+	// Ślimak
+	{0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
+	 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 0, 0, 1, 1, 1, 1, 1, 1, 0,
+	 1, 0, 1, 1, 0, 0, 0, 0, 1, 0,
+	 1, 0, 1, 0, 1, 0, 0, 0, 1, 0,
+	 1, 0, 1, 1, 1, 0, 0, 0, 1, 0,
+	 1, 0, 0, 0, 0, 1, 1, 1, 1, 0,
+	 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+
+	// Sygnał TTL
+	{0, 0, 0, 0, 0, 1, 1, 1, 1, 1,
+	 1, 1, 1, 1, 1, 1, 0, 0, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,
+	 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,
+	 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+
+	// Okrąg
+	{0, 0, 1, 1, 1, 1, 1, 0, 0, 0,
+	 0, 1, 1, 0, 0, 0, 1, 1, 1, 0,
+	 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
+	 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+	 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
+	 1, 1, 0, 0, 0, 0, 0, 0, 1, 1,
+	 0, 1, 0, 0, 0, 0, 0, 0, 1, 0,
+	 0, 1, 1, 0, 0, 0, 0, 1, 1, 0,
+	 0, 0, 1, 1, 1, 0, 0, 1, 0, 0,
+	 0, 0, 0, 0, 1, 1, 1, 1, 1, 1},
+
+	// Kwadrat
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+	 1, 0, 0, 0, 0, 0, 0, 1, 1, 1,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 1, 1, 1, 1, 1, 1, 1, 1, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
+
+	// ABACABA
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+	 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
+	 0, 0, 0, 1, 0, 0, 0, 1, 0, 0,
+	 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+	 0, 1, 0, 1, 0, 1, 0, 1, 0, 1,
+	 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+	 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
+
+	 // Paski
+	 {1, 1, 1, 0, 1, 0, 1, 0, 1, 0,
+	  1, 0, 1, 1, 1, 0, 1, 0, 1, 0,
+	  1, 0, 1, 0, 1, 1, 1, 0, 1, 0,
+	  1, 0, 1, 0, 1, 0, 1, 1, 1, 0,
+	  1, 0, 1, 0, 1, 0, 1, 0, 1, 1,
+	  1, 0, 1, 0, 1, 0, 1, 0, 1, 1,
+	  1, 0, 1, 0, 1, 0, 1, 1, 1, 0,
+	  1, 0, 1, 0, 1, 1, 1, 0, 1, 0,
+	  1, 0, 1, 1, 1, 0, 1, 0, 1, 0,
+	  1, 1, 1, 0, 1, 0, 1, 0, 1, 0},
+
+	// Puste pole
+	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
+
+};
+
+std::vector<unsigned short> siatka = {
+
+	// Możliwe stany pól siatki:
+	// - 0 - niezamalowana, nie do zamalowania (zielony)
+	// - 1 - niezamalowana, do zamalowania (złoty)
+	// - 2 - zamalowana,    nie do zamalowania (czerwony)
+	// - 3 - zamalowana,    do zamalowania (jasnozielony)
+
+	// 1. bit mówi o tym, czy jest do zamalowania
+	// 2. bit mówi o tym, czy jest zamalowana
+
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+
+};
+
+void sprawdzPostepGry() {
+	unsigned short zgodne_pola = 0;
+	for (int i = 0; i < 10; i++) {
+		for (int j = 0; j < 10; j++) {
+			// std::cout << "zgp: " << zgodne_pola << "\n";
+			unsigned short pole_w_siatce = siatka[10*i + (9 - j)];
+			bool pole_we_wzorach = wzory[biezacy_wzor][10*i + (9 - j)];
+			if (pole_w_siatce == 0 && pole_we_wzorach == 0) zgodne_pola++;
+			else if (pole_w_siatce == 3 && pole_we_wzorach == 1) zgodne_pola++;
+			else {
+				// std::cout << "dla i=" << i << " j=" << j << " otrzymano p_w_s " << pole_w_siatce << " a spodziewano sie p_w_w: " << pole_we_wzorach << "\n";
+				return;
+			}
+		}
+	}
+	if (zgodne_pola == 100) {
+		biezacy_wzor = (biezacy_wzor + 1) % (wzory.size() + 1);
+		Foward   =  45.0f;
+		Sides    = -45.0f;
+		Rotation = 270.0f;
+		nadpiszNowaSiatke(biezacy_wzor);
+	} else {
+		// std::cout << "zgodne_pola: " << zgodne_pola << "\n";
+	}
+}
+
+void ustalPozycjeGracza(GLfloat gracz_x, GLfloat gracz_z, short &grid_x, short &grid_z) {
+	grid_x = static_cast<int>(gracz_x) / 90;
+	grid_z = static_cast<int>(gracz_z) / 90;
+
+	// zapobiega rysowaniu ze "spawna"
+	if (gracz_x < 0 && gracz_x > -90) grid_x = -1; // ten przypadek dotyczy tylko noclipa
+	if (gracz_z < 0 && gracz_z > -90) grid_z = -1;
+}
+
+void ustawSiatkeNaWzorNieNadpisujacPostepu() {
+	for (int i = 0; i < 10; i++) {
+		for (int j = 0; j < 10; j++) {
+			bool ma_byc_zamalowana = wzory[biezacy_wzor][10*i + (9 - j)];
+			if (ma_byc_zamalowana) siatka[10*i + (9 - j)] |= 1;
+			else siatka[10*i + (9 - j)] = siatka[10*i + (9 - j)] - siatka[10*i + (9 - j)] % 2;
+		}
+	}
+}
+
+void nadpiszNowaSiatke(short nowy_wzor) {
+	biezacy_wzor = nowy_wzor;
+	for (int i = 0; i < 10; i++) {
+		for (int j = 0; j < 10; j++) {
+			siatka[10*i + (9 - j)] = static_cast<unsigned short>(wzory[biezacy_wzor][10*i + (9 - j)]);
+		}
+	}
+}
+
+void tworzKratke(unsigned int grid_x, unsigned int grid_z, unsigned short grid_value) {
+
+	// https://rgbcolorpicker.com/0-1
+	switch (grid_value) {
+
+		case 0:
+			// niezamalowana, nie do zamalowania (zielony)
+			glColor3d(0.031, 0.51, 0.094);
+			break;
+
+		case 1:
+			// niezamalowana, do zamalowania (złoty)
+			glColor3d(0.7, 0.5, 0.259);
+			break;
+
+		case 2:
+			// zamalowana, nie do zamalowania (czerwony)
+			glColor3d(1, 0.122, 0);
+			break;
+
+		case 3:
+			// zamalowana, do zamalowania (biały)
+			glColor3d(1, 1, 1);
+			break;
+
+	}
+
+	platforma(45.0f + grid_x * 90.0f, 0.0f, 45.0f + grid_z * 90.0f, 45.0f, 45.0f);
+
+}
+
+void tworzKratkiZSiatki() {
+	for (int i = 0; i < 10; i++) {
+		// Aby nie musieć rysować wzorów w odbiciu
+		// lustrzanym, musimy tutaj przyjąć inną sekwencję
+		// (dlatego rysujemy od prawej do lewej (9 do 0))
+		for (int j = 0; j < 10; j++) {
+			tworzKratke(i, j, siatka[10*i + (9 - j)]);
+		}
+	}
+}
+
+void aktualizujBiezacaKratke(short grid_x, short grid_z) {
+	if (grid_x < 0 || grid_z < 0) return;
+
+	unsigned short poprzednia_wartosc = siatka[10*grid_x + (9 - grid_z)];
+	siatka[10*grid_x + (9 - grid_z)] |= 2; // zaznacz pole jako zamalowane
+	unsigned short       nowa_wartosc = siatka[10*grid_x + (9 - grid_z)];
+	
+	// Jeżeli któreś z pól zostało zaktualizowane, sprawdź postęp gry
+	if (poprzednia_wartosc != nowa_wartosc) {
+		sprawdzPostepGry();
+	}
+}

fabula.hpp

@@ -0,0 +1,18 @@
+#pragma once
+#include <iostream>
+#include "GL/glew.h"
+#include <vector>
+
+extern short biezacy_wzor;
+extern float Foward;
+extern float Sides;
+extern float Rotation;
+extern void platforma(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat xlen, GLfloat zlen);
+
+void sprawdzPostepGry();
+void ustalPozycjeGracza(GLfloat gracz_x, GLfloat gracz_z, short &grid_x, short &grid_z);
+void ustawSiatkeNaWzorNieNadpisujacPostepu();
+void nadpiszNowaSiatke(short nowy_wzor);
+void tworzKratke(unsigned int grid_x, unsigned int grid_z, unsigned short grid_value);
+void tworzKratkiZSiatki();
+void aktualizujBiezacaKratke(short grid_x, short grid_z);

grafikaKBT.vcxproj

@@ -121,6 +121,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="fabula.cpp" />
     <ClCompile Include="FPSCounter.cpp" />
     <ClCompile Include="glew.c" />
     <ClCompile Include="Rover.cpp" />
@@ -129,15 +130,18 @@
     <ClCompile Include="main.cpp" />
     <ClCompile Include="plane.cpp" />
     <ClCompile Include="shader.cpp" />
+    <ClCompile Include="teksturowane.cpp" />
     <ClCompile Include="texture.cpp" />
     <ClCompile Include="timeh.cpp" />
   </ItemGroup>
   <ItemGroup>
+    <ClInclude Include="fabula.hpp" />
     <ClInclude Include="lazik.hpp" />
     <ClInclude Include="loadOBJ.h" />
     <ClInclude Include="plane.hpp" />
     <ClInclude Include="RESOURCE.H" />
     <ClInclude Include="shader.hpp" />
+    <ClInclude Include="teksturowane.hpp" />
     <ClInclude Include="texture.hpp" />
     <ClInclude Include="timeh.hpp" />
   </ItemGroup>

grafikaKBT.vcxproj.filters

@@ -45,6 +45,12 @@
     <ClCompile Include="Rover.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="fabula.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="teksturowane.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="loadOBJ.h">
@@ -68,6 +74,12 @@
     <ClInclude Include="texture.hpp">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="fabula.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="teksturowane.hpp">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="glfw3.dll">

main.cpp

@@ -1,4 +1,4 @@
-#define  _CRT_SECURE_NO_WARNINGS
+#define  _CRT_SECURE_NO_WARNINGS
 #ifdef _MSC_VER                         // Check if MS Visual C compiler
 #  pragma comment(lib, "opengl32.lib")  // Compiler-specific directive to avoid manually configuration
 #  pragma comment(lib, "glu32.lib")     // Link libraries
@@ -35,6 +35,8 @@
 #include "shader.hpp"
 #include "FPSCounter.cpp"
 #include <thread>
+#include "teksturowane.hpp"
+#include "fabula.hpp"
 
 using namespace glm;
 
@@ -78,13 +80,13 @@ std::time_t lastTime = std::time(nullptr);
 int monitormode = 1;
 int monitormodecounter = 0;
 std::time_t monitormodehelper;
-
+short biezacy_wzor = 0;
-
+bool panoramic_view = 0;
 
 //Zmienne do ruchu ##############################################^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 FPSCounter fpsCounter;
 
-static const int targetFPS = 144; // Celowany FPS
+static const int targetFPS = 250; // Celowany FPS
 //Fps counter
 static void LimitFPS(int targetFPS) {
 	static auto lastTime = std::chrono::high_resolution_clock::now();
@@ -109,90 +111,82 @@ bool keySPressed = false;
 bool keyAPressed = false;
 bool keyDPressed = false;
 
-float Foward = 0.0f;  // Pozycja łazika w przód/tył 
+float Foward   =  45.0f;  // Pozycja łazika w przód/tył 
-float Sides = 0.0f;    // Pozycja łazika w lewo/prawo
+float Sides    = -45.0f;  // Pozycja łazika w lewo/prawo
-float Rotation = 0.0f; // Rotacja łazika (w stopniach)
+float Rotation = 270.0f;  // Rotacja łazika (w stopniach)
 
+
+
+const float MinDistance = 20.0f;
+const float MaxDistance = 1000.0f;
 float CameraHeight = 50.0f;  // Wysokość kamery
-float MoveSpeed = 1.0f;      // Prędkość poruszania się
+float MoveSpeed = 0.5f;      // Prędkość poruszania się
 
 
 float velocity = 0.0f;         // Aktualna prędkość łazika
 float rotationVelocity = 0.0f; // Prędkość obrotu łazika
 
 
-const float friction = 0.1f; // Współczynnik tarcia (μ)
+const float friction = 0.05f;  // Współczynnik tarcia (μ)
-const float maxSpeed = 5.0f; // Maksymalna prędkość łazika
+const float maxSpeed = 2.0f;   // Maksymalna prędkość łazika
 const float acceleration = 0.2f;
 
 
-const float rotationAcceleration = 0.075f; // Przyspieszenie obrotu
+float rotationAcceleration = 0.075f; // Przyspieszenie obrotu
-const float rotationFriction = 0.1f; // Współczynnik tarcia obrotu
+float rotationFriction = 0.1f;       // Współczynnik tarcia obrotu
-const float maxRotationSpeed = 0.7f; // Maksymalna prędkość obrotu
+float maxRotationSpeed = 0.5f;       // Maksymalna prędkość obrotu
 
 // Struktura do reprezentacji płotu
 struct Plot {
     GLfloat xc;       // Środek płotu w osi X
-	GLfloat yc;       // Środek płotu w osi Y (nieużywane w kolizji, ale może być pomocne)
+    GLfloat yc;       // Środek (nieużywany w 2D)
     GLfloat zc;       // Środek płotu w osi Z
-	GLfloat length;   // Długość płotu
+    GLfloat length;   // Długość (dłuższy wymiar)
-	GLfloat gruboscY; // Grubość płotu
+    GLfloat grubosc;  // Szerokość/Grubość (krótszy wymiar)
-	bool mod_x;       // 0 - płot pionowy, 1 - płot poziomy
+    bool mod_x;       // 0 - płot wzdłuż osi Z (pionowy), 1 - płot wzdłuż osi X (poziomy)
 };
 
-// Funkcja sprawdzająca kolizję z płotem
+static bool CheckFenceCollision(float rXMin, float rXMax, float rZMin, float rZMax, const Plot& plot) {
-// Funkcja sprawdzająca kolizję z płotem, uwzględniając wymiary łazika
+    float fXMin, fXMax, fZMin, fZMax;
-static bool CheckFenceCollision(float roverXMin, float roverXMax, float roverZMin, float roverZMax, const Plot& plot) {
-	if (plot.mod_x == 0) { // Płot pionowy (równoległy do osi Z)
-		float xMin = plot.xc - plot.gruboscY / 2.0f;
-		float xMax = plot.xc + plot.gruboscY / 2.0f;
-		float zMin = plot.zc - plot.length / 2.0f;
-		float zMax = plot.zc + plot.length / 2.0f;
 
-		// Sprawdzenie, czy którykolwiek fragment łazika wchodzi w obszar płotu
+    if (plot.mod_x == 0) { // Płot pionowy (rozciąga się w osi Z)
-		if (roverXMax >= xMin && roverXMin <= xMax && // Kolizja w osi X
+        fXMin = plot.xc - plot.grubosc / 2.0f;
-			roverZMax >= zMin && roverZMin <= zMax) { // Kolizja w osi Z
+        fXMax = plot.xc + plot.grubosc / 2.0f;
-			return true;
+        fZMin = plot.zc - plot.length / 2.0f;
+        fZMax = plot.zc + plot.length / 2.0f;
+    } else {               // Płot poziomy (rozciąga się w osi X)
+        fXMin = plot.xc - plot.length / 2.0f;
+        fXMax = plot.xc + plot.length / 2.0f;
+        fZMin = plot.zc - plot.grubosc / 2.0f;
+        fZMax = plot.zc + plot.grubosc / 2.0f;
     }
-	}
-	else { // Płot poziomy (równoległy do osi X)
-		float xMin = plot.xc - plot.length / 2.0f;
-		float xMax = plot.xc + plot.length / 2.0f;
-		float zMin = plot.zc - plot.gruboscY / 2.0f;
-		float zMax = plot.zc + plot.gruboscY / 2.0f;
 
-		// Sprawdzenie, czy którykolwiek fragment łazika wchodzi w obszar płotu
+    // Standardowy test nakładania się prostokątów (AABB vs AABB)
-		if (roverXMax >= xMin && roverXMin <= xMax && // Kolizja w osi X
+    return (rXMax >= fXMin && rXMin <= fXMax && 
-			roverZMax >= zMin && roverZMin <= zMax) { // Kolizja w osi Z
+            rZMax >= fZMin && rZMin <= fZMax);
+}
+
+static bool CheckAllFencesCollision(float rXMin, float rXMax, float rZMin, float rZMax, const std::vector<Plot>& fences) {
+    for (const auto& fence : fences) {
+        if (CheckFenceCollision(rXMin, rXMax, rZMin, rZMax, fence)) {
             return true;
         }
     }
     return false;
 }
 
-// Funkcja ogólna do sprawdzania kolizji ze wszystkimi płotami
-static bool CheckAllFencesCollision(float roverXMin, float roverXMax, float roverZMin, float roverZMax, const std::vector<Plot>& fences) {
-	for (const auto& fence : fences) {
-		if (CheckFenceCollision(roverXMin, roverXMax, roverZMin, roverZMax, fence)) {
-			return true; // Kolizja wykryta z którymś płotem
-		}
-	}
-	return false; // Brak kolizji
-}
-
 static void UpdateRover(const std::vector<Plot>& fences) {
-    // Przyspieszanie w przód
+	// --- 1. OBSŁUGA PRZYSPIESZENIA (W / S) ---
 	if (keyWPressed) {
 		velocity += acceleration;
 		if (velocity > maxSpeed) velocity = maxSpeed;
 	}
-    // Przyspieszanie w tył
 	else if (keySPressed) {
 		velocity -= acceleration;
 		if (velocity < -maxSpeed) velocity = -maxSpeed;
 	}
-    // Hamowanie (wytracanie prędkości z powodu tarcia)
 	else {
+		// Hamowanie (tarcie)
 		if (velocity > 0) {
 			velocity -= friction;
 			if (velocity < 0) velocity = 0;
@@ -203,7 +197,7 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 		}
 	}
 
-    // Obracanie (rotacja z driftowaniem)
+	// --- 2. OBSŁUGA OBROTU (A / D) ---
 	if (keyAPressed) {
 		rotationVelocity += rotationAcceleration;
 		if (rotationVelocity > maxRotationSpeed) rotationVelocity = maxRotationSpeed;
@@ -213,8 +207,8 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 		if (rotationVelocity < -maxRotationSpeed) rotationVelocity = -maxRotationSpeed;
 	}
 	else {
-        // Jeśli żadna z klawiszy A/D nie jest wciśnięta, to stopniowo spowalniamy rotację (drift)
+		// Driftowanie (wytracanie rotacji)
-        float driftFactor = 0.1f;  // Mniejsza wartość = dłuższy drift
+		float driftFactor = 0.1f;
 		if (rotationVelocity > 0) {
 			rotationVelocity -= rotationFriction * driftFactor;
 			if (rotationVelocity < 0) rotationVelocity = 0;
@@ -225,133 +219,119 @@ static void UpdateRover(const std::vector<Plot>& fences) {
 		}
 	}
 
-    // Wyliczenie nowej pozycji na podstawie prędkości
+	// --- 3. LOGIKA ODWRÓCENIA SKRĘTU PRZY COFANIU ---
-    float radRotation = Rotation * GL_PI / 180.0f; // Przeliczamy rotację na radiany
+	// Jeśli prędkość jest ujemna, odwracamy wpływ rotationVelocity na kąt,
-    float newSides = Sides - velocity * cos(radRotation); // Nowa pozycja w osi X
+	// aby klawisz D zawsze kierował pojazd w prawo względem kamery.
-    float newFoward = Foward - velocity * sin(radRotation); // Nowa pozycja w osi Z
+	float actualRotationStep = rotationVelocity;
+	if (velocity < 0.0f) {
+		actualRotationStep = -rotationVelocity;
+	}
 
-    // Wymiary łazika (połówki w osi X i Z)
+	// --- 4. WYLICZENIE NOWEJ POZYCJI ---
-    const float roverHalfWidthX = 19.0f; // 38/2
+	float radRotation = Rotation * GL_PI / 180.0f;
-    const float roverHalfLengthZ = 12.0f; // 24/2
+	float newSides = Sides - velocity * cos(radRotation);
+	float newFoward = Foward - velocity * sin(radRotation);
 
-    // Wyliczenie obszaru zajmowanego przez łazik
+	// Wymiary łazika
+	const float roverHalfWidthX = 19.0f;
+	const float roverHalfLengthZ = 12.0f;
+
+	// Obszar zajmowany przez łazik (AABB dla ruchu prostoliniowego)
 	float roverXMin = newSides - roverHalfWidthX;
 	float roverXMax = newSides + roverHalfWidthX;
 	float roverZMin = newFoward - roverHalfLengthZ;
 	float roverZMax = newFoward + roverHalfLengthZ;
 
-    // Sprawdzanie kolizji przed aktualizacją pozycji
+	// --- 5. KOLIZJE I AKTUALIZACJA ---
-    if (!Kolizja == true) {
+	if (!Kolizja) {
+		// Kolizja przy ruchu przód/tył
 		if (CheckAllFencesCollision(roverZMin, roverZMax, roverXMin, roverXMax, fences)) {
-            // Jeśli jest kolizja, zatrzymujemy łazik
 			velocity = 0.0f;
-            //cout << "Kolizja podczas ruchu\n";
 		}
 		else {
-            // Jeśli brak kolizji, aktualizujemy pozycję
 			Sides = newSides;
 			Foward = newFoward;
 		}
 
-        // Sprawdzanie kolizji podczas obrotu
+		// Kolizja przy obrocie
-        if (rotationVelocity != 0.0f) {
+		if (actualRotationStep != 0.0f) {
-            // Wyliczamy nową rotację
+			float newRotation = Rotation + actualRotationStep;
-            float newRotation = Rotation + rotationVelocity;
 			float radNewRotation = newRotation * GL_PI / 180.0f;
 
-            // Obracamy narożniki łazika
+			// Punkty narożne do sprawdzenia po obrocie (OBB)
-            std::vector<std::pair<float, float>> corners(4);
+			std::vector<std::pair<float, float>> corners = {
-            corners[0] = {Sides - roverHalfWidthX, Foward - roverHalfLengthZ}; // Lewy dolny
+				{Sides - roverHalfWidthX, Foward - roverHalfLengthZ},
-            corners[1] = {Sides + roverHalfWidthX, Foward - roverHalfLengthZ}; // Prawy dolny
+				{Sides + roverHalfWidthX, Foward - roverHalfLengthZ},
-            corners[2] = {Sides - roverHalfWidthX, Foward + roverHalfLengthZ}; // Lewy górny
+				{Sides - roverHalfWidthX, Foward + roverHalfLengthZ},
-            corners[3] = {Sides + roverHalfWidthX, Foward + roverHalfLengthZ}; // Prawy górny
+				{Sides + roverHalfWidthX, Foward + roverHalfLengthZ}
+			};
+
 			bool collisionDetected = false;
-            // Obracamy wszystkie narożniki
 			for (auto& corner : corners) {
 				float x = corner.first;
 				float z = corner.second;
 
-				corner.first = Sides + (x - Sides) * cos(radNewRotation) - (z - Foward) * sin(radNewRotation);
+				// Rotacja punktów wokół środka łazika
-				corner.second = Foward + (x - Sides) * sin(radNewRotation) + (z - Foward) * cos(radNewRotation);
+				float rotatedX = Sides + (x - Sides) * cos(radNewRotation) - (z - Foward) * sin(radNewRotation);
+				float rotatedZ = Foward + (x - Sides) * sin(radNewRotation) + (z - Foward) * cos(radNewRotation);
 
-
+				if (CheckAllFencesCollision(rotatedX, rotatedX, rotatedZ, rotatedZ, fences)) {
-				// Sprawdzamy kolizję na podstawie obróconych narożników
-				
-
-				if (CheckAllFencesCollision(corner.first, corner.first, corner.second, corner.second, fences)) {
-					collisionDetected = true;
-					break;
-				}
-				if (CheckAllFencesCollision( corner.second, corner.second, corner.first, corner.first, fences)) {
 					collisionDetected = true;
 					break;
 				}
 			}
 
 			if (collisionDetected) {
-                rotationVelocity = 0.0f; // Zatrzymujemy obrót
+				rotationVelocity = 0.0f; // Blokujemy obrót
-                //cout << "Kolizja podczas obrotu\n";
+			}
-            } else {
+			else {
-                // Aktualizujemy rotację, jeśli nie ma kolizji
 				Rotation = newRotation;
-                if (Rotation >= 360.0f) Rotation -= 360.0f;
-                if (Rotation < 0.0f) Rotation += 360.0f;
 			}
 		}
 	}
 	else {
-        // Jeśli kolizje są wyłączone, aktualizujemy wszystko bez sprawdzania
+		// Kolizje wyłączone - aktualizuj bez pytań
 		Sides = newSides;
 		Foward = newFoward;
-        Rotation += rotationVelocity;
+		Rotation += actualRotationStep;
+	}
+
+	// Normalizacja kąta do zakresu 0-360
 	if (Rotation >= 360.0f) Rotation -= 360.0f;
 	if (Rotation < 0.0f)    Rotation += 360.0f;
 }
-}
-
-
-
-
-
 
 std::vector<Plot> fences = {
-	{-550.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0}, // 0 - pionowo
+	{  450.0f, 3.0f,   -90.0f, 900.0f, 4.0f, 1}, // 1 - poziomo
-	{  50.0f, 3.0f, -600.0f, 1200.0f, 4.0f, 1}, // 1 - poziomo
+	{    0.0f, 3.0f,   405.0f, 990.0f, 4.0f, 0}, // 0 - pionowo
-	{ 650.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0}, // 0 - pionowo
+	{  450.0f, 3.0f, 10*90.0f, 900.0f, 4.0f, 1}, // 1 - poziomo
-	{  50.0f, 3.0f,  695.0f, 1200.0f, 4.0f, 1}  // 1 - poziomo
+	{10*90.0f, 3.0f,   405.0f, 990.0f, 4.0f, 0}  // 0 - pionowo
 };
 
 // Change viewing volume and viewport. Called when window is resized
 void static ChangeSize(GLsizei w, GLsizei h) {
-	GLfloat nRange = 100.0f;
+	// Zabezpieczenie przed dzieleniem przez zero
-	//GLfloat fAspect;
-	// Prevent a divide by zero
 	if (h == 0) h = 1;
 
 	lastWidth = w;
 	lastHeight = h;
 
-	//fAspect = (GLfloat)w / (GLfloat)h;
+	// Obliczenie proporcji okna (Aspect Ratio)
-	// Set Viewport to window dimensions
+	GLfloat fAspect = (GLfloat)w / (GLfloat)h;
+
+	// Ustawienie obszaru renderowania
 	glViewport(0, 0, w, h);
 
-	// Reset coordinate system
+	// Reset macierzy projekcji
 	glMatrixMode(GL_PROJECTION);
 	glLoadIdentity();
 
-	// // Establish clipping volume (left, right, bottom, top, near, far)
+	// USTAWIENIE PERSPEKTYWY
-	// if (w <= h) glOrtho(-nRange, nRange, -nRange * h / w, nRange * h / w, -nRange, nRange);
+	// Parametry: (Kąt widzenia w stopniach, Proporcje okna, Bliska płaszczyzna, Daleka płaszczyzna)
-	// else glOrtho(-nRange * w / h, nRange * w / h, -nRange, nRange, -nRange, nRange);
+	// UWAGA: Bliska płaszczyzna (near) w perspektywie MUSI być większa od 0 (np. 1.0f)
-
+	gluPerspective(45.0f, fAspect, 1.0f, 2000.0f);
-	// Establish clipping volume (left, right, bottom, top, near, far)
-	if (w <= h) glOrtho(-nRange, nRange, -nRange * h / w, nRange * h / w, -20 * nRange, 20 * nRange);
-	else glOrtho(-nRange * w / h, nRange * w / h, -nRange, nRange, -20 * nRange, 20 * nRange);
-
-	// Establish perspective: 
-	/*
-	gluPerspective(60.0f, fAspect, 1.0, 400);
-	*/
 
+	// Powrót do macierzy widoku modelu
 	glMatrixMode(GL_MODELVIEW);
 	glLoadIdentity();
 }
@@ -445,363 +425,6 @@ void SetDCPixelFormat(HDC hDC) {
 	SetPixelFormat(hDC, nPixelFormat, &pfd);
 }
 
-static void skrzynka(GLfloat k) {
-	glColor3d(0.8, 0.7, 0.3);
-
-
-	glEnable(GL_TEXTURE_2D); // Włącz teksturowanie
-
-	glBindTexture(GL_TEXTURE_2D, texture[0]);
-	glBegin(GL_QUADS);
-		glNormal3d(0, 0, 1);
-		glTexCoord2d(1.0, 1.0); glVertex3d( k,  k, k);
-		glTexCoord2d(0.0, 1.0); glVertex3d(-k,  k, k);
-		glTexCoord2d(0.0, 0.0); glVertex3d(-k, -k, k);
-		glTexCoord2d(1.0, 0.0); glVertex3d( k, -k, k);
-	glEnd();
-	glBindTexture(GL_TEXTURE_2D, texture[1]);
-	glBegin(GL_QUADS);
-		glNormal3d(1, 0, 0);
-		glTexCoord2d(1.0, 1.0); glVertex3d(k,  k,  k);
-		glTexCoord2d(0.0, 1.0); glVertex3d(k, -k,  k);
-		glTexCoord2d(0.0, 0.0); glVertex3d(k, -k, -k);
-		glTexCoord2d(1.0, 0.0); glVertex3d(k,  k, -k);
-	glEnd();
-
-	glDisable(GL_TEXTURE_2D); // Wyłącz teksturowanie
-
-
-	glBegin(GL_QUADS);
-		glNormal3d(0, 0, -1);
-		glVertex3d( k,  k, -k);
-		glVertex3d( k, -k, -k);
-		glVertex3d(-k, -k, -k);
-		glVertex3d(-k,  k, -k);
-
-		glNormal3d(-1, 0, 0);
-		glVertex3d(-k,  k, -k);
-		glVertex3d(-k, -k, -k);
-		glVertex3d(-k, -k,  k);
-		glVertex3d(-k,  k,  k);
-
-		glNormal3d(0, 1, 0);
-		glVertex3d( k, k,  k);
-		glVertex3d( k, k, -k);
-		glVertex3d(-k, k, -k);
-		glVertex3d(-k, k,  k);
-
-		glNormal3d(0, -1, 0);
-		glVertex3d( k, -k,  k);
-		glVertex3d(-k, -k,  k);
-		glVertex3d(-k, -k, -k);
-		glVertex3d( k, -k, -k);
-	glEnd();
-}
-
-static void platforma(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat xlen, GLfloat zlen) {
-	glColor3d(0.729, 0.91, 0.51); // jasnozielony, dla grass02.bmp
-
-	glEnable(GL_TEXTURE_2D);
-	glBindTexture(GL_TEXTURE_2D, texture[1]); // Wybieramy teksturę
-
-	// Ustawienie powtarzania tekstury
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT); // Powtarzanie w kierunku S
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT); // Powtarzanie w kierunku T
-
-	glBegin(GL_QUADS);
-	// Powtarzające się współrzędne tekstury (np. *5, aby powtórzyła się 5 razy)
-	glTexCoord2d(5.0, 5.0); glVertex3d(xc - xlen, yc, zc - zlen); // Lewy dolny
-	glTexCoord2d(5.0, 0.0); glVertex3d(xc + xlen, yc, zc - zlen); // Prawy dolny
-	glTexCoord2d(0.0, 0.0); glVertex3d(xc + xlen, yc, zc + zlen); // Prawy górny
-	glTexCoord2d(0.0, 5.0); glVertex3d(xc - xlen, yc, zc + zlen); // Lewy górny
-	glEnd();
-
-	glDisable(GL_TEXTURE_2D);
-}
-
-
-static void stodola(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat krawedz) {
-
-	glEnable(GL_TEXTURE_2D);
-
-	// ściany stodoły z bruku (brickwall)
-	glColor3d(0.612f, 0.573f, 0.478f); // ciemny szary popadający w brąz (https://rgbcolorpicker.com/0-1)
-	glBindTexture(GL_TEXTURE_2D, texture[3]);
-	glBegin(GL_QUADS);
-
-		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc - krawedz/2);
-		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc - krawedz/2);
-		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + krawedz, zc - krawedz/2);
-		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,           yc, zc - krawedz/2);
-
-		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc - krawedz/2);
-		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc - krawedz/2);
-		glTexCoord2d(0.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc + krawedz/2);
-		glTexCoord2d(0.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc + krawedz/2);
-
-		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc + krawedz/2);
-		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc + krawedz/2);
-		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + krawedz, zc + krawedz/2);
-		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,           yc, zc + krawedz/2);
-
-	glEnd();
-
-	// przód i tył dachu
-	glColor3d(0.612f, 0.573f, 0.478f);
-	glBindTexture(GL_TEXTURE_2D, texture[3]);
-	glBegin(GL_TRIANGLES);
-
-		glTexCoord2f(1.0, 1.0); glVertex3f(xc - krawedz/2,       yc + krawedz, zc - krawedz/2);
-		glTexCoord2f(1.0, 0.0); glVertex3f(xc - krawedz/2, yc + 1.5 * krawedz,             zc);
-		glTexCoord2f(0.0, 0.0); glVertex3f(xc - krawedz/2,       yc + krawedz, zc + krawedz/2);
-
-		glTexCoord2f(1.0, 1.0); glVertex3f(xc + krawedz/2,       yc + krawedz, zc - krawedz/2);
-		glTexCoord2f(1.0, 0.0); glVertex3f(xc + krawedz/2, yc + 1.5 * krawedz,             zc);
-		glTexCoord2f(0.0, 0.0); glVertex3f(xc + krawedz/2,       yc + krawedz, zc + krawedz/2);
-
-	glEnd();
-
-
-	// dach stodoły (barnroof)
-	glColor3d(0.639, 0.553, 0.322); // wyblakły brązowy
-	glBindTexture(GL_TEXTURE_2D, texture[2]);
-	glBegin(GL_QUADS);
-
-		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,       yc + krawedz, zc + krawedz/2);
-		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + 1.5 * krawedz,             zc);
-		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + 1.5 * krawedz,             zc);
-		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,       yc + krawedz, zc + krawedz/2);
-
-		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,       yc + krawedz, zc - krawedz/2);
-		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + 1.5 * krawedz,             zc);
-		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + 1.5 * krawedz,             zc);
-		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,       yc + krawedz, zc - krawedz/2);
-
-	glEnd();
-
-	glDisable(GL_TEXTURE_2D);
-
-}
-
-static void plot(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat length, GLfloat gruboscY, bool mod_x)
- {
-
-	GLfloat grubosc = 1.0f;
-
-	// timestampedCout("main.cpp (plot): otrzymano xc=" << xc << " yc=" << yc << " zc=" << zc << " length=" << length << " mod_x=" << mod_x);
-
-	GLfloat gruboscX = grubosc +  mod_x * length;
-	GLfloat gruboscZ = grubosc + !mod_x * length;
-
-	// timestampedCout("main.cpp (plot): gruboscX=" << gruboscX << " gruboscY=" << gruboscY << " gruboscZ=" << gruboscZ);
-
-	//   d-----------c   Y
-	//  /           /|   ^
-	// a-----------b |    \
-	// | h         | g     C->X
-	// |           |/      |
-	// e-----------f       v
-	//                     Z (płaszczyzna XZ, Y to trzeci wymiar)
-	
-	GLfloat a1_x = xc - gruboscX / 2,  a1_y = yc   + 1 + gruboscY,   a1_z = zc + gruboscZ / 2; // 3
-	GLfloat b1_x = xc + gruboscX / 2,  b1_y = yc   + 1 + gruboscY,   b1_z = zc + gruboscZ / 2;
-	GLfloat c1_x = xc + gruboscX / 2,  c1_y = yc   + 1 + gruboscY,   c1_z = zc - gruboscZ / 2;
-	GLfloat d1_x = xc - gruboscX / 2,  d1_y = yc   + 1 + gruboscY,   d1_z = zc - gruboscZ / 2;
-	GLfloat e1_x = xc - gruboscX / 2,  e1_y = yc   + 1           ,   e1_z = zc + gruboscZ / 2; // 1
-	GLfloat f1_x = xc + gruboscX / 2,  f1_y = yc   + 1           ,   f1_z = zc + gruboscZ / 2;
-	GLfloat g1_x = xc + gruboscX / 2,  g1_y = yc   + 1           ,   g1_z = zc - gruboscZ / 2;
-	GLfloat h1_x = xc - gruboscX / 2,  h1_y = yc   + 1           ,   h1_z = zc - gruboscZ / 2;
-
-	GLfloat a2_x = a1_x,               a2_y = a1_y - 1 - gruboscY,  a2_z = a1_z; //zc - 1; // -4
-	GLfloat b2_x = b1_x,               b2_y = b1_y - 1 - gruboscY,  b2_z = b1_z; //zc - 1;
-	GLfloat c2_x = c1_x,               c2_y = c1_y - 1 - gruboscY,  c2_z = c1_z; //zc - 1;
-	GLfloat d2_x = d1_x,               d2_y = d1_y - 1 - gruboscY,  d2_z = d1_z; //zc - 1;
-	GLfloat e2_x = e1_x,               e2_y = e1_y - 1 - gruboscY,  e2_z = e1_z; //zc - 2;
-	GLfloat f2_x = f1_x,               f2_y = f1_y - 1 - gruboscY,  f2_z = f1_z; //zc - 2;
-	GLfloat g2_x = g1_x,               g2_y = g1_y - 1 - gruboscY,  g2_z = g1_z; //zc - 2;
-	GLfloat h2_x = h1_x,               h2_y = h1_y - 1 - gruboscY,  h2_z = h1_z; //zc - 2;
-
-	glColor3d(0.71, 0.522, 0.067);
-
-	glEnable(GL_TEXTURE_2D);
-	glBindTexture(GL_TEXTURE_2D, texture[0]);
-	glBegin(GL_QUADS);
-
-		// Góra (1_x, 1_y, 1_z):
-		// ABCD
-		glTexCoord2d(1.0, 1.0); glVertex3d(a1_x, a1_y, a1_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(b1_x, b1_y, b1_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(d1_x, d1_y, d1_z);
-
-		// EFGH
-		glTexCoord2d(1.0, 1.0); glVertex3d(e1_x, e1_y, e1_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(f1_x, f1_y, f1_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(g1_x, g1_y, g1_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(h1_x, h1_y, h1_z);
-
-		// BCGF
-		glTexCoord2d(1.0, 1.0); glVertex3d(b1_x, b1_y, b1_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(g1_x, g1_y, g1_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(f1_x, f1_y, f1_z);
-
-		// ADHE
-		glTexCoord2d(1.0, 1.0); glVertex3d(a1_x, a1_y, a1_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(b1_x, b1_y, b1_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(d1_x, d1_y, d1_z);
-
-		// ABFE
-		glTexCoord2d(1.0, 1.0); glVertex3d(a1_x, a1_y, a1_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(b1_x, b1_y, b1_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(f1_x, f1_y, f1_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(e1_x, e1_y, e1_z);
-
-		// DCGH
-		glTexCoord2d(1.0, 1.0); glVertex3d(d1_x, d1_y, d1_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(g1_x, g1_y, g1_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(h1_x, h1_y, h1_z);
-
-		// Dół (2_x, 2_y, 2_z):
-		// ABCD
-		glTexCoord2d(1.0, 1.0); glVertex3d(a2_x, a2_y, a2_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(b2_x, b2_y, b2_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(d2_x, d2_y, d2_z);
-
-		// EFGH
-		glTexCoord2d(1.0, 1.0); glVertex3d(e2_x, e2_y, e2_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(f2_x, f2_y, f2_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(g2_x, g2_y, g2_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(h2_x, h2_y, h2_z);
-
-		// BCGF
-		glTexCoord2d(1.0, 1.0); glVertex3d(b2_x, b2_y, b2_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(g2_x, g2_y, g2_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(f2_x, f2_y, f2_z);
-
-		// ADHE
-		glTexCoord2d(1.0, 1.0); glVertex3d(a2_x, a2_y, a2_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(b2_x, b2_y, b2_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(d2_x, d2_y, d2_z);
-
-		// ABFE
-		glTexCoord2d(1.0, 1.0); glVertex3d(a2_x, a2_y, a2_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(b2_x, b2_y, b2_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(f2_x, f2_y, f2_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(e2_x, e2_y, e2_z);
-
-		// DCGH
-		glTexCoord2d(1.0, 1.0); glVertex3d(d2_x, d2_y, d2_z);
-		glTexCoord2d(1.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
-		glTexCoord2d(0.0, 0.0); glVertex3d(g2_x, g2_y, g2_z);
-		glTexCoord2d(0.0, 1.0); glVertex3d(h2_x, h2_y, h2_z);
-
-		// Pachołki
-
-		//   d-----------c   Y
-		//  /           /|   ^
-		// a-----------b |    \
-		// | h         | g     C->X
-		// |           |/      |
-		// e-----------f       v
-		//                     Z (płaszczyzna XZ, Y to trzeci wymiar)
-
-
-		GLfloat p_a_x, p_a_y, p_a_z;
-		GLfloat p_b_x, p_b_y, p_b_z;
-		GLfloat p_c_x, p_c_y, p_c_z;
-		GLfloat p_d_x, p_d_y, p_d_z;
-		GLfloat p_e_x, p_e_y, p_e_z;
-		GLfloat p_f_x, p_f_y, p_f_z;
-		GLfloat p_g_x, p_g_y, p_g_z;
-		GLfloat p_h_x, p_h_y, p_h_z;
-
-		if (!mod_x) {
-
-			p_a_x = xc + gruboscX / 2,  p_a_y = yc + 1.5f * gruboscY,  p_a_z = zc; // +3 dla y
-			p_b_x = xc - gruboscX / 2,  p_b_y = yc + 1.5f * gruboscY,  p_b_z = zc; // +3 dla y
-			p_c_x = xc + gruboscX / 2,  p_c_y = yc + 1.5f * gruboscY,  p_c_z = zc; // +3 dla y
-			p_d_x = xc - gruboscX / 2,  p_d_y = yc + 1.5f * gruboscY,  p_d_z = zc; // +3 dla y
-			p_e_x = xc + gruboscX / 2,  p_e_y = yc - 6              ,  p_e_z = zc;
-			p_f_x = xc - gruboscX / 2,  p_f_y = yc - 6              ,  p_f_z = zc;
-			p_g_x = xc + gruboscX / 2,  p_g_y = yc - 6              ,  p_g_z = zc;
-			p_h_x = xc - gruboscX / 2,  p_h_y = yc - 6              ,  p_h_z = zc;
-
-		} else {
-
-			p_a_x = xc,                 p_a_y = yc + 1.5f * gruboscY,  p_a_z = zc - gruboscZ / 2; // +3 dla y
-			p_b_x = xc,                 p_b_y = yc + 1.5f * gruboscY,  p_b_z = zc - gruboscZ / 2; // +3 dla y
-			p_c_x = xc,                 p_c_y = yc + 1.5f * gruboscY,  p_c_z = zc + gruboscZ / 2; // +3 dla y
-			p_d_x = xc,                 p_d_y = yc + 1.5f * gruboscY,  p_d_z = zc + gruboscZ / 2; // +3 dla y
-			p_e_x = xc,                 p_e_y = yc - 6              ,  p_e_z = zc - gruboscZ / 2;
-			p_f_x = xc,                 p_f_y = yc - 6              ,  p_f_z = zc - gruboscZ / 2;
-			p_g_x = xc,                 p_g_y = yc - 6              ,  p_g_z = zc + gruboscZ / 2;
-			p_h_x = xc,                 p_h_y = yc - 6              ,  p_h_z = zc + gruboscZ / 2;
-
-		}
-
-		for (int i = 0; i < 2; i++) {
-
-			//   d-----------c   Y
-			//  /           /|   ^
-			// a-----------b |    \
-			// | h         | g     C->X
-			// |           |/      |
-			// e-----------f       v
-			//                     Z (płaszczyzna XZ, Y to trzeci wymiar)
-
-			// timestampedCout("main.cpp (plot): p_a_x=" << p_a_x << " p_b_x=" << p_b_x << " p_c_x=" << p_c_x << " p_d_x=" << p_d_x);
-
-			// ABCD
-			glTexCoord2d(1.0, 1.0); glVertex3d(p_a_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_a_y, p_a_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(1.0, 0.0); glVertex3d(p_b_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_b_y, p_b_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(0.0, 0.0); glVertex3d(p_c_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_c_y, p_c_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 1.0); glVertex3d(p_d_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_d_y, p_d_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-
-			// EFGH
-			glTexCoord2d(1.0, 1.0); glVertex3d(p_e_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_e_y, p_e_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(1.0, 0.0); glVertex3d(p_f_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_f_y, p_f_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(0.0, 0.0); glVertex3d(p_g_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_g_y, p_g_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 1.0); glVertex3d(p_h_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_h_y, p_h_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-
-			// BCGF
-			glTexCoord2d(1.0, 1.0); glVertex3d(p_b_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_b_y, p_b_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(1.0, 0.0); glVertex3d(p_c_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_c_y, p_c_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 0.0); glVertex3d(p_g_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_g_y, p_g_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 1.0); glVertex3d(p_f_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_f_y, p_f_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-
-			// ADHE
-			glTexCoord2d(1.0, 1.0); glVertex3d(p_a_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_a_y, p_a_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(1.0, 0.0); glVertex3d(p_d_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_d_y, p_d_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 0.0); glVertex3d(p_h_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_h_y, p_h_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 1.0); glVertex3d(p_e_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_e_y, p_e_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-
-			// ABFE
-			glTexCoord2d(1.0, 1.0); glVertex3d(p_a_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_a_y, p_a_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(1.0, 0.0); glVertex3d(p_b_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_b_y, p_b_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(0.0, 0.0); glVertex3d(p_f_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_f_y, p_f_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-			glTexCoord2d(0.0, 1.0); glVertex3d(p_e_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_e_y, p_e_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
-
-			// DCGH
-			glTexCoord2d(1.0, 1.0); glVertex3d(p_d_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_d_y, p_d_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(1.0, 0.0); glVertex3d(p_c_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_c_y, p_c_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 0.0); glVertex3d(p_g_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_g_y, p_g_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-			glTexCoord2d(0.0, 1.0); glVertex3d(p_h_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_h_y, p_h_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
-
-		}
-
-
-	glEnd();
-
-	glDisable(GL_TEXTURE_2D);
-
-}
-
 //GLuint programID, VertexArrayID, MatrixID;
 lazik user(10.0f, 0.0f, 0.0f, "res/models/lazik4.obj"); // obiekty eksportujemy z Forward Axis Z, Up Axis Y.
 plane mapa( 0.0f, 0.0f, 0.0f, "res/models/mapka3_nofence_noplatform.obj");
@@ -848,11 +471,11 @@ static void SetupRC() {
 	glEnable(GL_LIGHT2);
 
 	// Setup and enable light 3
-	glLightfv(GL_LIGHT3, GL_AMBIENT, ambientLight);
+	// glLightfv(GL_LIGHT3, GL_AMBIENT, ambientLight);
-	glLightfv(GL_LIGHT3, GL_DIFFUSE, diffuseLight);
+	// glLightfv(GL_LIGHT3, GL_DIFFUSE, diffuseLight);
-	glLightfv(GL_LIGHT3, GL_SPECULAR, specular);
+	// glLightfv(GL_LIGHT3, GL_SPECULAR, specular);
-	glLightfv(GL_LIGHT3, GL_POSITION, lightPos4);
+	// glLightfv(GL_LIGHT3, GL_POSITION, lightPos4);
-	glEnable(GL_LIGHT3);
+	// glEnable(GL_LIGHT3);
 
 	// Enable color tracking
 	glEnable(GL_COLOR_MATERIAL);
@@ -897,11 +520,13 @@ static void SetupRC() {
 
 
 void static RenderScene(void) {
+
+	// PS: to nie zadziała, bo okno nie jest tworzone przez glfw
 	// Ustawienie liczby próbek dla antyaliasingu
-	glfwWindowHint(GLFW_SAMPLES, 16);  // 4x MSAA (Wielokrotne próbkowanie)
+	// glfwWindowHint(GLFW_SAMPLES, 16);  // 4x MSAA (Wielokrotne próbkowanie)
 
 	// Włączenie antyaliasingu (MSAA)
-	glEnable(GL_MULTISAMPLE);
+	//glEnable(GL_MULTISAMPLE);
 
 	// Przywrócenie macierzy modelu i ustawienie obrotów
 	glPushMatrix();
@@ -921,20 +546,51 @@ void static RenderScene(void) {
 	// Czyszczenie ekranu przed rysowaniem
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
-	// Przywrócenie macierzy widoku
+	// Widok panoramiczny (SHIFT/F5)
+	// Pomocnicza konwersja na radiany
+	float rad = Rotation * GL_PI / 180.0f;
+
+	if (panoramic_view) {
+		// --- WIDOK Z GÓRY (STRATEGICZNY) ---
+		maxRotationSpeed = 1.0f;
+		rotationFriction = 0.5f;
+
+		float mapZoom = 400.0f; // Wysokość, z której patrzymy
 		gluLookAt(
-		Foward - 50.0f * sin((Rotation + 180.0f) * GL_PI / 180.0f),      // Pozycja kamery
+			Foward, mapZoom, Sides,    // Kamera wysoko nad łazikiem
-		CameraHeight/4,                                                  // Wysokość kamery
+			Foward, 0.0f, Sides,       // Patrzymy prosto na łazik
-		Sides - 50.0f * cos((Rotation + 180.0f) * GL_PI / 180.0f),       // Kamera wzdłuż osi X i Z
+			1.0f, 0.0f, 0.0f           // ZMIANA: Wektor góry to oś X (bo patrzymy w dół osi Y)
-		Foward, 0.0f, Sides,                                             // Punkt patrzenia (łazik)
-		0.0f, 1.0f, 0.0f                                                 // Wektor "góry"
 		);
+	}
+	else {
+		maxRotationSpeed = 0.5f;
+		rotationFriction = 0.1f;
+
+		float rad = Rotation * GL_PI / 180.0f;
+
+		// Obliczamy pozycję kamery korzystając z dynamicznego CameraDistance
+		float camX = Foward + CameraHeight * sin(rad);
+		float camZ = Sides + CameraHeight * cos(rad);
+
+		// Wysokość kamery też może się skalować z dystansem (opcjonalnie)
+		float dynamicHeight = CameraHeight * 0.4f;
+
+		gluLookAt(
+			camX, dynamicHeight, camZ,   // Pozycja kamery
+			Foward, 10.0f, Sides,        // Patrzymy na łazik
+			0.0f, 1.0f, 0.0f             // Góra
+		);
+	}
+	
 
 	// Rysowanie mapy
 	glPushMatrix();
-	glColor3f(0.0, 1.0, 0.0);  // Zielony kolor
+	// glColor3f(0.0, 1.0, 0.0);  // Zielony kolor
-	mapa.draw();
+	// mapa.draw(); // nie rysuj mapy/terenu .obj
-	platforma(50.0f, 0.0f, 45.0f, 600.0f, 650.0f);
+
+	// Platforma niebędąca częścią siatki:
+	glColor3d(0.031, 0.51, 0.094); // ciemnozielony
+	platforma(450.0f, 0.0f, -45.0f, 450.0f, 45.0f);
 	glPopMatrix();
 
 	// Rysowanie łazika
@@ -942,18 +598,28 @@ void static RenderScene(void) {
 	glTranslatef(Foward, 0.0f, Sides);      // Translacja łazika
 	glRotatef(Rotation, 0.0f, 1.0f, 0.0f);  // Obrót łazika
 	glColor3f(1.0, 0.0, 0.0);               // Czerwony kolor dla łazika
-	
+	user.draw();                            // Rysuj łazik z pomocą lazik.cpp
-	user.draw();
 	UpdateRover(fences);
 	fpsCounter.update();
 	glPopMatrix();
 
+	// std::cout << "X: " << Foward << " Z: " << Sides << " Rotation: " << Rotation << "\n";
+
 	// Rysowanie innych obiektów
-	plot(-550.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0); // 0 - pionowo
+	// 1 pole siatki = 90x90m
-	plot(  50.0f, 3.0f, -600.0f, 1200.0f, 4.0f, 1); // 1 - poziomo
+	plot(  450.0f, 3.0f,    -90.0f, 900.0f, 4.0f, 1); // 1 - poziomo
-	plot( 650.0f, 3.0f,   50.0f, 1310.0f, 4.0f, 0);
+	plot(    0.0f, 3.0f,    405.0f, 990.0f, 4.0f, 0); // 0 - pionowo
-	plot(  50.0f, 3.0f,  695.0f, 1200.0f, 4.0f, 1);
+	plot(  450.0f, 3.0f,  10*90.0f, 900.0f, 4.0f, 1); // 1 - poziomo
-	stodola(10.0f, 0.0f, 2.0f, 40.0f);
+	plot(10*90.0f, 3.0f,    405.0f, 990.0f, 4.0f, 0); // 0 - pionowo
+	stodola(45.0f, 0.0f, -45.0f, 70.0f);
+
+	// Mechanika gry
+	short grid_x, grid_z;
+	ustalPozycjeGracza(Foward, Sides, grid_x, grid_z);
+	// std::cout << "grid_X: " << grid_x << " grid_Z: " << grid_z << " status: " << siatka[10*grid_x + (9 - grid_z)] << "\n";
+	ustawSiatkeNaWzorNieNadpisujacPostepu();
+	tworzKratkiZSiatki();
+	aktualizujBiezacaKratke(grid_x, grid_z);
 
 	// Zamiana buforów (double buffering)
 	// glfwSwapBuffers(window); // Przełączenie buforów
@@ -964,6 +630,7 @@ void static RenderScene(void) {
 
 	// Wymuszenie wykonania wszystkich rysunków
 	glFlush();
+
 }
 
 
@@ -1038,7 +705,9 @@ HPALETTE static GetOpenGLPalette(HDC hDC) {
 	// Return the handle to the new palette
 	return hRetPal;
 }
+
 void static CreateConsole() {
+
 	// Tworzenie nowej konsoli
 	if (AllocConsole()) {
 		// Przekierowanie standardowych strumieni do konsoli
@@ -1048,18 +717,19 @@ void static CreateConsole() {
 		freopen_s(&conin, "conin$", "r", stdin);
 		freopen_s(&conout, "conout$", "w", stdout);
 		freopen_s(&conerr, "conout$", "w", stderr);
-	}
+	} else {
-	else {
 		MessageBox(NULL, "Nie udalo sie utworzyc konsoli.", "Blad", MB_OK | MB_ICONERROR);
 	}
+
 }
+
 int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
+
 	CreateConsole();
 	MSG             msg;   // Windows message structure
 	WNDCLASS        wc{};  // Windows class structure
 	HWND            hWnd;  // Storeage for window handle
 
-
 	hInstance = hInst;
 		
 	// Register Window style
@@ -1103,9 +773,8 @@ void static CreateConsole() {
 
 	const WORD ID_TIMER = 1;
 	SetTimer(hWnd, ID_TIMER, 100, NULL);
+
 	// Display the window
-
-
 	ShowWindow(hWnd, SW_SHOW);
 	UpdateWindow(hWnd);
 
@@ -1128,6 +797,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 	switch (message) {
 		// Window creation, setup for OpenGL
 		case WM_CREATE:
+
 			// Store the device context
 			hDC = GetDC(hWnd);
 
@@ -1220,8 +890,8 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 		// Window is being destroyed, cleanup
 		case WM_DESTROY:
-			user.unload();
 
+			user.unload();
 			//glDeleteProgram(programID);
 			//glDeleteVertexArrays(1, &VertexArrayID);
 
@@ -1239,6 +909,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 		// Window is resized.
 		case WM_SIZE:
+
 			// Call our function which modifies the clipping
 			// volume and viewport
 			ChangeSize(LOWORD(lParam), HIWORD(lParam));
@@ -1256,13 +927,7 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 			// Validate the newly painted client area
 			if (!monitormode) ValidateRect(hWnd, NULL);
 			else InvalidateRect(hWnd, NULL, FALSE);
-			//break;
+			break;
-
-			// Limit FPS
-			// Uaktualniaj FPS
-			// Ogranicz FPS
-
-			
 
 		case WM_QUERYNEWPALETTE:
 			// If the palette was created.
@@ -1299,8 +964,27 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				// Remap the current colors to the newly realized palette
 				UpdateColors(hDC);
 				return 0;
+
 			}
 			break;
+		
+		case WM_MOUSEWHEEL:
+		{
+			// Pobieramy informację o tym, jak mocno obrócono kółko
+			int zDelta = GET_WHEEL_DELTA_WPARAM(wParam);
+
+			// Zmieniamy dystans kamery (podzielone przez 120, bo tyle wynosi jeden "skok" scrolla)
+			CameraHeight -= (float)zDelta * 0.1f;
+
+			// Ograniczamy zoom, żeby nie wejść kamerą "w łazik" ani nie odlecieć w kosmos
+			if (CameraHeight < MinDistance) CameraHeight = MinDistance;
+			if (CameraHeight > MaxDistance) CameraHeight = MaxDistance;
+
+			// Odświeżamy okno
+			InvalidateRect(hWnd, NULL, FALSE);
+		}
+		break;
+
 		case WM_KEYUP:
 
 			switch (wParam) {
@@ -1393,6 +1077,18 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 				// 	if (!monitormode) timestampedCout("Wylaczono tryb monitorowania wydajnosci.");
 				// 	break;
 
+				case 116: // F5 włącza widok panoramiczny
+					panoramic_view = !panoramic_view;
+					break;
+
+				case 16: // Shift również
+					panoramic_view = !panoramic_view;
+					break;
+
+				case 8: // Backspace czyści postęp
+					nadpiszNowaSiatke(biezacy_wzor);
+					break;
+
 				default:
 					timestampedCout("Nacisnieto nierozpoznany klawisz: " << (int)wParam);
 			}

teksturowane.cpp

@@ -0,0 +1,357 @@
+#include "teksturowane.hpp"
+
+void skrzynka(GLfloat k) {
+	glColor3d(0.8, 0.7, 0.3);
+
+
+	glEnable(GL_TEXTURE_2D); // Włącz teksturowanie
+
+	glBindTexture(GL_TEXTURE_2D, texture[0]);
+	glBegin(GL_QUADS);
+		glNormal3d(0, 0, 1);
+		glTexCoord2d(1.0, 1.0); glVertex3d( k,  k, k);
+		glTexCoord2d(0.0, 1.0); glVertex3d(-k,  k, k);
+		glTexCoord2d(0.0, 0.0); glVertex3d(-k, -k, k);
+		glTexCoord2d(1.0, 0.0); glVertex3d( k, -k, k);
+	glEnd();
+	glBindTexture(GL_TEXTURE_2D, texture[1]);
+	glBegin(GL_QUADS);
+		glNormal3d(1, 0, 0);
+		glTexCoord2d(1.0, 1.0); glVertex3d(k,  k,  k);
+		glTexCoord2d(0.0, 1.0); glVertex3d(k, -k,  k);
+		glTexCoord2d(0.0, 0.0); glVertex3d(k, -k, -k);
+		glTexCoord2d(1.0, 0.0); glVertex3d(k,  k, -k);
+	glEnd();
+
+	glDisable(GL_TEXTURE_2D); // Wyłącz teksturowanie
+
+
+	glBegin(GL_QUADS);
+		glNormal3d(0, 0, -1);
+		glVertex3d( k,  k, -k);
+		glVertex3d( k, -k, -k);
+		glVertex3d(-k, -k, -k);
+		glVertex3d(-k,  k, -k);
+
+		glNormal3d(-1, 0, 0);
+		glVertex3d(-k,  k, -k);
+		glVertex3d(-k, -k, -k);
+		glVertex3d(-k, -k,  k);
+		glVertex3d(-k,  k,  k);
+
+		glNormal3d(0, 1, 0);
+		glVertex3d( k, k,  k);
+		glVertex3d( k, k, -k);
+		glVertex3d(-k, k, -k);
+		glVertex3d(-k, k,  k);
+
+		glNormal3d(0, -1, 0);
+		glVertex3d( k, -k,  k);
+		glVertex3d(-k, -k,  k);
+		glVertex3d(-k, -k, -k);
+		glVertex3d( k, -k, -k);
+	glEnd();
+}
+
+void platforma(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat xlen, GLfloat zlen) {
+	// glColor3d(0.729, 0.91, 0.51); // jasnozielony, dla grass02.bmp
+
+	glEnable(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, texture[1]); // Wybieramy teksturę
+
+	// Ustawienie powtarzania tekstury
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_MIRRORED_REPEAT); // Powtarzanie w kierunku S
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_MIRRORED_REPEAT); // Powtarzanie w kierunku T
+
+	glBegin(GL_QUADS);
+	// Powtarzające się współrzędne tekstury (np. *5, aby powtórzyła się 5 razy)
+	glTexCoord2d(5.0, 5.0); glVertex3d(xc - xlen, yc, zc - zlen); // Lewy dolny
+	glTexCoord2d(5.0, 0.0); glVertex3d(xc + xlen, yc, zc - zlen); // Prawy dolny
+	glTexCoord2d(0.0, 0.0); glVertex3d(xc + xlen, yc, zc + zlen); // Prawy górny
+	glTexCoord2d(0.0, 5.0); glVertex3d(xc - xlen, yc, zc + zlen); // Lewy górny
+	glEnd();
+
+	glDisable(GL_TEXTURE_2D);
+}
+
+
+void stodola(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat krawedz) {
+
+	glEnable(GL_TEXTURE_2D);
+
+	// ściany stodoły z bruku (brickwall)
+	glColor3d(0.612f, 0.573f, 0.478f); // ciemny szary popadający w brąz (https://rgbcolorpicker.com/0-1)
+	glBindTexture(GL_TEXTURE_2D, texture[3]);
+	glBegin(GL_QUADS);
+
+		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc - krawedz/2);
+		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc - krawedz/2);
+		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + krawedz, zc - krawedz/2);
+		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,           yc, zc - krawedz/2);
+
+		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc - krawedz/2);
+		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc - krawedz/2);
+		glTexCoord2d(0.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc + krawedz/2);
+		glTexCoord2d(0.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc + krawedz/2);
+
+		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,           yc, zc + krawedz/2);
+		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + krawedz, zc + krawedz/2);
+		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + krawedz, zc + krawedz/2);
+		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,           yc, zc + krawedz/2);
+
+	glEnd();
+
+	// przód i tył dachu
+	glColor3d(0.612f, 0.573f, 0.478f);
+	glBindTexture(GL_TEXTURE_2D, texture[3]);
+	glBegin(GL_TRIANGLES);
+
+		glTexCoord2f(1.0, 1.0); glVertex3f(xc - krawedz/2,       yc + krawedz, zc - krawedz/2);
+		glTexCoord2f(1.0, 0.0); glVertex3f(xc - krawedz/2, yc + 1.5 * krawedz,             zc);
+		glTexCoord2f(0.0, 0.0); glVertex3f(xc - krawedz/2,       yc + krawedz, zc + krawedz/2);
+
+		glTexCoord2f(1.0, 1.0); glVertex3f(xc + krawedz/2,       yc + krawedz, zc - krawedz/2);
+		glTexCoord2f(1.0, 0.0); glVertex3f(xc + krawedz/2, yc + 1.5 * krawedz,             zc);
+		glTexCoord2f(0.0, 0.0); glVertex3f(xc + krawedz/2,       yc + krawedz, zc + krawedz/2);
+
+	glEnd();
+
+
+	// dach stodoły (barnroof)
+	glColor3d(0.639, 0.553, 0.322); // wyblakły brązowy
+	glBindTexture(GL_TEXTURE_2D, texture[2]);
+	glBegin(GL_QUADS);
+
+		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,       yc + krawedz, zc + krawedz/2);
+		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + 1.5 * krawedz,             zc);
+		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + 1.5 * krawedz,             zc);
+		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,       yc + krawedz, zc + krawedz/2);
+
+		glTexCoord2d(1.0, 1.0); glVertex3d(xc - krawedz/2,       yc + krawedz, zc - krawedz/2);
+		glTexCoord2d(1.0, 0.0); glVertex3d(xc - krawedz/2, yc + 1.5 * krawedz,             zc);
+		glTexCoord2d(0.0, 0.0); glVertex3d(xc + krawedz/2, yc + 1.5 * krawedz,             zc);
+		glTexCoord2d(0.0, 1.0); glVertex3d(xc + krawedz/2,       yc + krawedz, zc - krawedz/2);
+
+	glEnd();
+
+	glDisable(GL_TEXTURE_2D);
+
+}
+
+void plot(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat length, GLfloat gruboscY, bool mod_x) {
+
+	GLfloat grubosc = 1.0f;
+
+	// timestampedCout("main.cpp (plot): otrzymano xc=" << xc << " yc=" << yc << " zc=" << zc << " length=" << length << " mod_x=" << mod_x);
+
+	GLfloat gruboscX = grubosc +  mod_x * length;
+	GLfloat gruboscZ = grubosc + !mod_x * length;
+
+	// timestampedCout("main.cpp (plot): gruboscX=" << gruboscX << " gruboscY=" << gruboscY << " gruboscZ=" << gruboscZ);
+
+	//   d-----------c   Y
+	//  /           /|   ^
+	// a-----------b |    \
+	// | h         | g     C->X
+	// |           |/      |
+	// e-----------f       v
+	//                     Z (płaszczyzna XZ, Y to trzeci wymiar)
+	
+	GLfloat a1_x = xc - gruboscX / 2,  a1_y = yc   + 1 + gruboscY,   a1_z = zc + gruboscZ / 2; // 3
+	GLfloat b1_x = xc + gruboscX / 2,  b1_y = yc   + 1 + gruboscY,   b1_z = zc + gruboscZ / 2;
+	GLfloat c1_x = xc + gruboscX / 2,  c1_y = yc   + 1 + gruboscY,   c1_z = zc - gruboscZ / 2;
+	GLfloat d1_x = xc - gruboscX / 2,  d1_y = yc   + 1 + gruboscY,   d1_z = zc - gruboscZ / 2;
+	GLfloat e1_x = xc - gruboscX / 2,  e1_y = yc   + 1           ,   e1_z = zc + gruboscZ / 2; // 1
+	GLfloat f1_x = xc + gruboscX / 2,  f1_y = yc   + 1           ,   f1_z = zc + gruboscZ / 2;
+	GLfloat g1_x = xc + gruboscX / 2,  g1_y = yc   + 1           ,   g1_z = zc - gruboscZ / 2;
+	GLfloat h1_x = xc - gruboscX / 2,  h1_y = yc   + 1           ,   h1_z = zc - gruboscZ / 2;
+
+	GLfloat a2_x = a1_x,               a2_y = a1_y - 1 - gruboscY,  a2_z = a1_z; //zc - 1; // -4
+	GLfloat b2_x = b1_x,               b2_y = b1_y - 1 - gruboscY,  b2_z = b1_z; //zc - 1;
+	GLfloat c2_x = c1_x,               c2_y = c1_y - 1 - gruboscY,  c2_z = c1_z; //zc - 1;
+	GLfloat d2_x = d1_x,               d2_y = d1_y - 1 - gruboscY,  d2_z = d1_z; //zc - 1;
+	GLfloat e2_x = e1_x,               e2_y = e1_y - 1 - gruboscY,  e2_z = e1_z; //zc - 2;
+	GLfloat f2_x = f1_x,               f2_y = f1_y - 1 - gruboscY,  f2_z = f1_z; //zc - 2;
+	GLfloat g2_x = g1_x,               g2_y = g1_y - 1 - gruboscY,  g2_z = g1_z; //zc - 2;
+	GLfloat h2_x = h1_x,               h2_y = h1_y - 1 - gruboscY,  h2_z = h1_z; //zc - 2;
+
+	glColor3d(0.71, 0.522, 0.067);
+
+	glEnable(GL_TEXTURE_2D);
+	glBindTexture(GL_TEXTURE_2D, texture[0]);
+	glBegin(GL_QUADS);
+
+		// Góra (1_x, 1_y, 1_z):
+		// ABCD
+		glTexCoord2d(1.0, 1.0); glVertex3d(a1_x, a1_y, a1_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(b1_x, b1_y, b1_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(d1_x, d1_y, d1_z);
+
+		// EFGH
+		glTexCoord2d(1.0, 1.0); glVertex3d(e1_x, e1_y, e1_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(f1_x, f1_y, f1_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(g1_x, g1_y, g1_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(h1_x, h1_y, h1_z);
+
+		// BCGF
+		glTexCoord2d(1.0, 1.0); glVertex3d(b1_x, b1_y, b1_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(g1_x, g1_y, g1_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(f1_x, f1_y, f1_z);
+
+		// ADHE
+		glTexCoord2d(1.0, 1.0); glVertex3d(a1_x, a1_y, a1_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(b1_x, b1_y, b1_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(d1_x, d1_y, d1_z);
+
+		// ABFE
+		glTexCoord2d(1.0, 1.0); glVertex3d(a1_x, a1_y, a1_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(b1_x, b1_y, b1_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(f1_x, f1_y, f1_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(e1_x, e1_y, e1_z);
+
+		// DCGH
+		glTexCoord2d(1.0, 1.0); glVertex3d(d1_x, d1_y, d1_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(c1_x, c1_y, c1_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(g1_x, g1_y, g1_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(h1_x, h1_y, h1_z);
+
+		// Dół (2_x, 2_y, 2_z):
+		// ABCD
+		glTexCoord2d(1.0, 1.0); glVertex3d(a2_x, a2_y, a2_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(b2_x, b2_y, b2_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(d2_x, d2_y, d2_z);
+
+		// EFGH
+		glTexCoord2d(1.0, 1.0); glVertex3d(e2_x, e2_y, e2_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(f2_x, f2_y, f2_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(g2_x, g2_y, g2_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(h2_x, h2_y, h2_z);
+
+		// BCGF
+		glTexCoord2d(1.0, 1.0); glVertex3d(b2_x, b2_y, b2_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(g2_x, g2_y, g2_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(f2_x, f2_y, f2_z);
+
+		// ADHE
+		glTexCoord2d(1.0, 1.0); glVertex3d(a2_x, a2_y, a2_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(b2_x, b2_y, b2_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(d2_x, d2_y, d2_z);
+
+		// ABFE
+		glTexCoord2d(1.0, 1.0); glVertex3d(a2_x, a2_y, a2_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(b2_x, b2_y, b2_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(f2_x, f2_y, f2_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(e2_x, e2_y, e2_z);
+
+		// DCGH
+		glTexCoord2d(1.0, 1.0); glVertex3d(d2_x, d2_y, d2_z);
+		glTexCoord2d(1.0, 0.0); glVertex3d(c2_x, c2_y, c2_z);
+		glTexCoord2d(0.0, 0.0); glVertex3d(g2_x, g2_y, g2_z);
+		glTexCoord2d(0.0, 1.0); glVertex3d(h2_x, h2_y, h2_z);
+
+		// Pachołki
+
+		//   d-----------c   Y
+		//  /           /|   ^
+		// a-----------b |    \
+		// | h         | g     C->X
+		// |           |/      |
+		// e-----------f       v
+		//                     Z (płaszczyzna XZ, Y to trzeci wymiar)
+
+
+		GLfloat p_a_x, p_a_y, p_a_z;
+		GLfloat p_b_x, p_b_y, p_b_z;
+		GLfloat p_c_x, p_c_y, p_c_z;
+		GLfloat p_d_x, p_d_y, p_d_z;
+		GLfloat p_e_x, p_e_y, p_e_z;
+		GLfloat p_f_x, p_f_y, p_f_z;
+		GLfloat p_g_x, p_g_y, p_g_z;
+		GLfloat p_h_x, p_h_y, p_h_z;
+
+		if (!mod_x) {
+
+			p_a_x = xc + gruboscX / 2,  p_a_y = yc + 1.5f * gruboscY,  p_a_z = zc; // +3 dla y
+			p_b_x = xc - gruboscX / 2,  p_b_y = yc + 1.5f * gruboscY,  p_b_z = zc; // +3 dla y
+			p_c_x = xc + gruboscX / 2,  p_c_y = yc + 1.5f * gruboscY,  p_c_z = zc; // +3 dla y
+			p_d_x = xc - gruboscX / 2,  p_d_y = yc + 1.5f * gruboscY,  p_d_z = zc; // +3 dla y
+			p_e_x = xc + gruboscX / 2,  p_e_y = yc - 6              ,  p_e_z = zc;
+			p_f_x = xc - gruboscX / 2,  p_f_y = yc - 6              ,  p_f_z = zc;
+			p_g_x = xc + gruboscX / 2,  p_g_y = yc - 6              ,  p_g_z = zc;
+			p_h_x = xc - gruboscX / 2,  p_h_y = yc - 6              ,  p_h_z = zc;
+
+		} else {
+
+			p_a_x = xc,                 p_a_y = yc + 1.5f * gruboscY,  p_a_z = zc - gruboscZ / 2; // +3 dla y
+			p_b_x = xc,                 p_b_y = yc + 1.5f * gruboscY,  p_b_z = zc - gruboscZ / 2; // +3 dla y
+			p_c_x = xc,                 p_c_y = yc + 1.5f * gruboscY,  p_c_z = zc + gruboscZ / 2; // +3 dla y
+			p_d_x = xc,                 p_d_y = yc + 1.5f * gruboscY,  p_d_z = zc + gruboscZ / 2; // +3 dla y
+			p_e_x = xc,                 p_e_y = yc - 6              ,  p_e_z = zc - gruboscZ / 2;
+			p_f_x = xc,                 p_f_y = yc - 6              ,  p_f_z = zc - gruboscZ / 2;
+			p_g_x = xc,                 p_g_y = yc - 6              ,  p_g_z = zc + gruboscZ / 2;
+			p_h_x = xc,                 p_h_y = yc - 6              ,  p_h_z = zc + gruboscZ / 2;
+
+		}
+
+		for (int i = 0; i < 2; i++) {
+
+			//   d-----------c   Y
+			//  /           /|   ^
+			// a-----------b |    \
+			// | h         | g     C->X
+			// |           |/      |
+			// e-----------f       v
+			//                     Z (płaszczyzna XZ, Y to trzeci wymiar)
+
+			// timestampedCout("main.cpp (plot): p_a_x=" << p_a_x << " p_b_x=" << p_b_x << " p_c_x=" << p_c_x << " p_d_x=" << p_d_x);
+
+			// ABCD
+			glTexCoord2d(1.0, 1.0); glVertex3d(p_a_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_a_y, p_a_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(1.0, 0.0); glVertex3d(p_b_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_b_y, p_b_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(0.0, 0.0); glVertex3d(p_c_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_c_y, p_c_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 1.0); glVertex3d(p_d_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_d_y, p_d_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+
+			// EFGH
+			glTexCoord2d(1.0, 1.0); glVertex3d(p_e_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_e_y, p_e_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(1.0, 0.0); glVertex3d(p_f_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_f_y, p_f_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(0.0, 0.0); glVertex3d(p_g_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_g_y, p_g_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 1.0); glVertex3d(p_h_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_h_y, p_h_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+
+			// BCGF
+			glTexCoord2d(1.0, 1.0); glVertex3d(p_b_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_b_y, p_b_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(1.0, 0.0); glVertex3d(p_c_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_c_y, p_c_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 0.0); glVertex3d(p_g_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_g_y, p_g_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 1.0); glVertex3d(p_f_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_f_y, p_f_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+
+			// ADHE
+			glTexCoord2d(1.0, 1.0); glVertex3d(p_a_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_a_y, p_a_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(1.0, 0.0); glVertex3d(p_d_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_d_y, p_d_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 0.0); glVertex3d(p_h_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_h_y, p_h_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 1.0); glVertex3d(p_e_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_e_y, p_e_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+
+			// ABFE
+			glTexCoord2d(1.0, 1.0); glVertex3d(p_a_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_a_y, p_a_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(1.0, 0.0); glVertex3d(p_b_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_b_y, p_b_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(0.0, 0.0); glVertex3d(p_f_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_f_y, p_f_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+			glTexCoord2d(0.0, 1.0); glVertex3d(p_e_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_e_y, p_e_z + (2*i-1) * (gruboscZ/2 - 5) * !mod_x);
+
+			// DCGH
+			glTexCoord2d(1.0, 1.0); glVertex3d(p_d_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_d_y, p_d_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(1.0, 0.0); glVertex3d(p_c_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_c_y, p_c_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 0.0); glVertex3d(p_g_x + (2*i-1) * (gruboscX/2 - 5) * mod_x, p_g_y, p_g_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+			glTexCoord2d(0.0, 1.0); glVertex3d(p_h_x + (2*i-1) * (gruboscX/2 - 8) * mod_x, p_h_y, p_h_z + (2*i-1) * (gruboscZ/2 - 8) * !mod_x);
+
+		}
+
+
+	glEnd();
+
+	glDisable(GL_TEXTURE_2D);
+
+}

teksturowane.hpp

@@ -0,0 +1,9 @@
+#pragma once
+#include "GL/glew.h"
+
+extern unsigned int texture[4];
+
+void skrzynka(GLfloat k);
+void platforma(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat xlen, GLfloat zlen);
+void stodola(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat krawedz);
+void plot(GLfloat xc, GLfloat yc, GLfloat zc, GLfloat length, GLfloat gruboscY, bool mod_x);