To co w nazwie brancha + konsola w vsc

FPSCounter.cpp

@@ -0,0 +1,24 @@
+#include <iostream>
+#include <chrono>
+
+class FPSCounter {
+public:
+    FPSCounter() : frameCount(0), lastTime(std::chrono::high_resolution_clock::now()) {}
+
+    void update() {
+        frameCount++;
+        auto currentTime = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double> elapsed = currentTime - lastTime;
+
+        if (elapsed.count() >= 1.0) {
+            double fps = frameCount / elapsed.count();
+            std::cout << "FPS: " << fps << std::endl;
+            frameCount = 0;
+            lastTime = currentTime;
+        }
+    }
+
+private:
+    int frameCount;
+    std::chrono::time_point<std::chrono::high_resolution_clock> lastTime;
+};

grafikaKBT.vcxproj

@@ -121,6 +121,7 @@
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
+    <ClCompile Include="FPSCounter.cpp" />
     <ClCompile Include="glew.c" />
     <ClCompile Include="lazik.cpp" />
     <ClCompile Include="loadOBJ.cpp" />

grafikaKBT.vcxproj.filters

@@ -33,6 +33,9 @@
     <ClCompile Include="plane.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="FPSCounter.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="loadOBJ.h">

main.cpp

@@ -31,6 +31,8 @@
 #include "GL/glfw3.h"
 #include <ctime>
 #include "timeh.hpp"
+#include "FPSCounter.cpp"
+#include <thread>
 
 using namespace glm;
 
@@ -71,47 +73,29 @@ void SetDCPixelFormat(HDC hDC);
 
 int polygonmode = 0;
 std::time_t lastTime = std::time(nullptr);
-int monitormode = 0;
+int monitormode = 1;
 int monitormodecounter = 0;
 std::time_t monitormodehelper;
 
-//Zmienne do ruchu ##############################################
-/*
-float Foward = 0.0f;  // Pozycja łazika w przód/tył
-float Sides = 0.0f;    // Pozycja łazika w lewo/prawo
-float Rotation = 0.0f; // Rotacja łazika (w stopniach)
 
-// Zmienne do sterowania kamerą
-float CameraHeight = 50.0f;  // Wysokość kamery
 
-void MoveRover(bool forward) {
-	// Zamieniamy kąt na radiany
-	float radRotation = Rotation * GL_PI / 180.0f;
-
-	// Wektor ruchu w kierunku przód/tył (kierunek łazika)
-	float moveX = cos(radRotation);
-	float moveZ = sin(radRotation);
-
-	// Ruch w przód
-	if (forward) {
-		Sides -= 1.1f * moveX;
-		Foward -= 1.1f * moveZ;
-	}
-	// Ruch w tył
-	else {
-		Sides += 1.1f * moveX;
-		Foward += 1.1f * moveZ;
-	}
-}
-
-// Funkcja do obrotu kamery i łazika (A/D)
-void RotateRoverAndCamera(float angle) {
-	Rotation += angle;
-	if (Rotation >= 360.0f) Rotation -= 360.0f;
-	if (Rotation < 0.0f) Rotation += 360.0f;
-}
-*/
 //Zmienne do ruchu ##############################################^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+FPSCounter fpsCounter;
+static const int targetFPS = 144; // Celowany FPS
+//Fps counter
+void LimitFPS(int targetFPS) {
+	static auto lastTime = std::chrono::high_resolution_clock::now();
+	auto currentTime = std::chrono::high_resolution_clock::now();
+	std::chrono::duration<double> elapsed = currentTime - lastTime;
+
+	// Jeśli upłynęło za mało czasu, aby osiągnąć target FPS, czekamy
+	double frameTime = 1.0 / targetFPS; // Czas na jedną klatkę w sekundach
+	if (elapsed.count() < frameTime) {
+		std::this_thread::sleep_for(std::chrono::duration<double>(frameTime - elapsed.count()));
+	}
+
+	lastTime = std::chrono::high_resolution_clock::now();
+}
 bool keyWPressed = false;
 bool keySPressed = false;
 bool keyAPressed = false;
@@ -122,7 +106,20 @@ float Sides = 0.0f;    // Pozycja łazika w lewo/prawo
 float Rotation = 0.0f; // Rotacja łazika (w stopniach)
 
 float CameraHeight = 50.0f;  // Wysokość kamery
-float MoveSpeed = 3.0f;      // Prędkość poruszania się
+float MoveSpeed = 1.0f;      // Prędkość poruszania się
+
+
+float velocity = 0.0f;       // Aktualna prędkość łazika
+const float friction = 0.05f; // Współczynnik tarcia (μ)
+const float maxSpeed = 3.0f; // Maksymalna prędkość łazika
+const float acceleration = 0.2f;
+float rotationVelocity = 0.0f; // Prędkość obrotu łazika
+const float rotationAcceleration = 0.1f; // Przyspieszenie obrotu
+const float rotationFriction = 0.05f; // Współczynnik tarcia obrotu
+const float maxRotationSpeed = 3.0f; // Maksymalna prędkość obrotu
+
+
+
 
 // Funkcja do poruszania łazikiem
 void MoveRover(bool forward) {
@@ -153,48 +150,58 @@ void RotateRoverAndCamera(float angle) {
 }
 
 void UpdateRover() {
+	// Przyspieszanie w przód
 	if (keyWPressed) {
-		if (keyAPressed) {
-			// Ruch do przodu i skręt w lewo
-			RotateRoverAndCamera(3.0f); // Dostosuj wartość kąta według potrzeb
-			MoveRover(true);
+		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 {
+		if (velocity > 0) {
+			velocity -= friction;
+			if (velocity < 0) velocity = 0;
 		}
-		else if (keyDPressed) {
-			// Ruch do przodu i skręt w prawo
-			RotateRoverAndCamera(-3.0f); // Dostosuj wartość kąta według potrzeb
-			MoveRover(true);
-		}
-		else {
-			// Ruch do przodu bez skrętu
-			MoveRover(true);
+		else if (velocity < 0) {
+			velocity += friction;
+			if (velocity > 0) velocity = 0;
 		}
 	}
-	else if (keySPressed) {
-		if (keyAPressed) {
-			// Ruch do tyłu i skręt w lewo
-			RotateRoverAndCamera(-3.0f); // Dostosuj wartość kąta według potrzeb
-			MoveRover(false);
-		}
-		else if (keyDPressed) {
-			// Ruch do tyłu i skręt w prawo
-			RotateRoverAndCamera(3.0f); // Dostosuj wartość kąta według potrzeb
-			MoveRover(false);
-		}
-		else {
-			// Ruch do tyłu bez skrętu
-			MoveRover(false);
-		}
+
+	// Obracanie
+	if (keyAPressed) {
+		rotationVelocity += rotationAcceleration;
+		if (rotationVelocity > maxRotationSpeed) rotationVelocity = maxRotationSpeed;
+	}
+	else if (keyDPressed) {
+		rotationVelocity -= rotationAcceleration;
+		if (rotationVelocity < -maxRotationSpeed) rotationVelocity = -maxRotationSpeed;
 	}
 	else {
-		if (keyAPressed) {
-			// Obrót w miejscu w lewo
-			RotateRoverAndCamera(3.0f); // Dostosuj wartość kąta według potrzeb
+		// Hamowanie obrotu (wytracanie prędkości z powodu tarcia)
+		if (rotationVelocity > 0) {
+			rotationVelocity -= rotationFriction;
+			if (rotationVelocity < 0) rotationVelocity = 0;
 		}
-		else if (keyDPressed) {
-			// Obrót w miejscu w prawo
-			RotateRoverAndCamera(-3.0f); // Dostosuj wartość kąta według potrzeb
+		else if (rotationVelocity < 0) {
+			rotationVelocity += rotationFriction;
+			if (rotationVelocity > 0) rotationVelocity = 0;
 		}
 	}
+
+	// Aktualizacja pozycji na podstawie prędkości
+	float radRotation = Rotation * GL_PI / 180.0f;
+	Sides -= velocity * cos(radRotation);
+	Foward -= velocity * sin(radRotation);
+
+	// Aktualizacja kąta obrotu
+	Rotation += rotationVelocity;
+	if (Rotation >= 360.0f) Rotation -= 360.0f;
+	if (Rotation < 0.0f) Rotation += 360.0f;
 }
 
 // Change viewing volume and viewport. Called when window is resized
@@ -400,7 +407,7 @@ void SetupRC() {
 }
 
 void RenderScene(void) {
-
+	
 	//float normal[3];	// Storage for calculated surface normal
 
 	// Save the matrix state and do the rotations
@@ -425,19 +432,7 @@ void RenderScene(void) {
 		glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
 	}
 
-	// prymitywny licznik FPS
-	if (monitormode) {
-		std::time_t now_t = std::time(nullptr);
-		yRot -= 1; // showcase demo
-		if (now_t > monitormodehelper) {
-			std::cout << (int)(monitormodecounter / (now_t - monitormodehelper)) << " fps\n";
-			monitormodehelper = now_t;
-			monitormodecounter = 0;
-		}
-		else {
-			monitormodecounter++;
-		}
-	}
+	
 
 	// Clear the screen
 	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
@@ -456,9 +451,9 @@ void RenderScene(void) {
 	//Sterowanie 
 	//############################################################################################
 	gluLookAt(
-		Foward - 50.0f * sin((Rotation + 180.0f) * GL_PI / 180.0f), // Pozycja kamery wokół łazika (w poziomie)
+		Foward - 100.0f * sin((Rotation + 180.0f) * GL_PI / 180.0f), // Pozycja kamery wokół łazika (w poziomie)
 		CameraHeight,                                             // Wysokość kamery
-		Sides - 50.0f * cos((Rotation + 180.0f) * GL_PI / 180.0f),  // Kamera wzdłuż osi X i Z
+		Sides - 100.0f * cos((Rotation + 180.0f) * GL_PI / 180.0f),  // Kamera wzdłuż osi X i Z
 		Foward, 0.0f, Sides,                                      // Punkt, na który patrzy kamera (łazik)
 		0.0f, 1.0f, 0.0f                                         // Wektor "góry"
 	);
@@ -478,7 +473,7 @@ void RenderScene(void) {
 	user.draw();
 	UpdateRover();
 	glPopMatrix();
-
+	fpsCounter.update();
 
 	// Zamiana buforów (double buffering)
 
@@ -568,66 +563,88 @@ HPALETTE GetOpenGLPalette(HDC hDC) {
 	// Return the handle to the new palette
 	return hRetPal;
 }
-
-int APIENTRY WinMain(HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) {
-
-	MSG             msg;   // Windows message structure
-	WNDCLASS        wc;    // Windows class structure
-	HWND            hWnd;  // Storeage for window handle
-
-	hInstance = hInst;
-
-	// Register Window style
-	wc.style = CS_HREDRAW | CS_VREDRAW;
-	wc.lpfnWndProc = (WNDPROC)WndProc;
-	wc.cbClsExtra = 0;
-	wc.cbWndExtra = 0;
-	wc.hInstance = hInstance;
-	wc.hIcon = NULL;
-	wc.hCursor = LoadCursor(NULL, IDC_ARROW);
-
-	// No need for background brush for OpenGL window
-	wc.hbrBackground = NULL;
-
-	wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
-	wc.lpszClassName = lpszAppName;
-
-	// Register the window class
-	if (RegisterClass(&wc) == 0) return FALSE;
-
-
-	// Create the main application window
-	hWnd = CreateWindow(
-		lpszAppName,
-		lpszAppName,
-
-		// OpenGL requires WS_CLIPCHILDREN and WS_CLIPSIBLINGS
-		WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
-
-		// Window position and size
-		50, 50,
-		400, 400,
-		NULL,
-		NULL,
-		hInstance,
-		NULL);
-
-	// If window was not created, quit
-	if (hWnd == NULL) return FALSE;
-
-
-	// Display the window
-	ShowWindow(hWnd, SW_SHOW);
-	UpdateWindow(hWnd);
-
-	// Process application messages until the application closes
-	while (GetMessage(&msg, NULL, 0, 0)) {
-		TranslateMessage(&msg);
-		DispatchMessage(&msg);
+void CreateConsole()
+{
+	// Tworzenie nowej konsoli
+	if (AllocConsole())
+	{
+		// Przekierowanie standardowych strumieni do konsoli
+		FILE* conin;
+		FILE* conout;
+		FILE* conerr;
+		freopen_s(&conin, "conin$", "r", stdin);
+		freopen_s(&conout, "conout$", "w", stdout);
+		freopen_s(&conerr, "conout$", "w", stderr);
+	}
+	else
+	{
+		MessageBox(NULL, "Nie udało się utworzyć konsoli.", "Błąd", MB_OK | MB_ICONERROR);
 	}
-
-	return msg.wParam;
 }
+	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
+		wc.style = CS_HREDRAW | CS_VREDRAW;
+		wc.lpfnWndProc = (WNDPROC)WndProc;
+		wc.cbClsExtra = 0;
+		wc.cbWndExtra = 0;
+		wc.hInstance = hInstance;
+		wc.hIcon = NULL;
+		wc.hCursor = LoadCursor(NULL, IDC_ARROW);
+
+		// No need for background brush for OpenGL window
+		wc.hbrBackground = NULL;
+
+		wc.lpszMenuName = MAKEINTRESOURCE(IDR_MENU);
+		wc.lpszClassName = lpszAppName;
+
+		// Register the window class
+		if (RegisterClass(&wc) == 0) return FALSE;
+
+
+		// Create the main application window
+		hWnd = CreateWindow(
+			lpszAppName,
+			lpszAppName,
+
+			// OpenGL requires WS_CLIPCHILDREN and WS_CLIPSIBLINGS
+			WS_OVERLAPPEDWINDOW | WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
+
+			// Window position and size
+			50, 50,
+			800, 800,
+			NULL,
+			NULL,
+			hInstance,
+			NULL);
+
+		// If window was not created, quit
+		if (hWnd == NULL) return FALSE;
+
+
+		const WORD ID_TIMER = 1;
+		SetTimer(hWnd, ID_TIMER, 100, NULL);
+		// Display the window
+
+
+		ShowWindow(hWnd, SW_SHOW);
+		UpdateWindow(hWnd);
+
+		// Process application messages until the application closes
+		while (GetMessage(&msg, NULL, 0, 0)) {
+			TranslateMessage(&msg);
+			DispatchMessage(&msg);
+		}
+
+		return msg.wParam;
+	}
 
 
 // Window procedure, handles all messages for this program
@@ -725,13 +742,19 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 		SwapBuffers(hDC);
 
 		// Validate the newly painted client area
-		if (!monitormode) ValidateRect(hWnd, NULL);
-		else InvalidateRect(hWnd, NULL, FALSE);
-		break;
+		if (!monitormode) {
+			ValidateRect(hWnd, NULL);
+		}
+		else {
+			InvalidateRect(hWnd, NULL, FALSE);
+		}
 
-		// Windows is telling the application that it may modify
-		// the system palette.  This message in essance asks the 
-		// application for a new palette.
+		// Limit FPS
+		LimitFPS(targetFPS);
+
+		// Update FPS counter
+		fpsCounter.update();
+		break;
 	case WM_QUERYNEWPALETTE:
 		// If the palette was created.
 		if (hPalette) {
@@ -841,15 +864,8 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 		case 'D':
 			keyDPressed = true;
 			break;
-
-		case 114: // F3
-			monitormode = !monitormode;
-			if (monitormode) {
-				monitormodehelper = std::time(nullptr) - 1;
-				timestampedCout("Wlaczono tryb monitorowania wydajnosci.");
-			}
-			if (!monitormode) timestampedCout("Wylaczono tryb monitorowania wydajnosci.");
-			break;
+		
+		
 
 		default:
 			timestampedCout("Nacisnieto nierozpoznany klawisz: " << (int)wParam);
@@ -879,7 +895,13 @@ LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
 
 		}
 		break;
-
+	case WM_TIMER:
+	{
+		RenderScene();
+		SwapBuffers(hDC);
+		ValidateRect(hWnd, NULL);
+		break;
+	}
 	default:   // Passes it on if unproccessed
 		return (DefWindowProc(hWnd, message, wParam, lParam));
 	}
@@ -936,4 +958,4 @@ BOOL APIENTRY AboutDlgProc(HWND hDlg, UINT message, UINT wParam, LONG lParam) {
 	}
 
 	return FALSE;
-}
+}