Init commit. Windows version was checked.

README.md

@@ -0,0 +1,65 @@
+# IPA projekt 2024  
+
+## Cíl projektu  
+
+Cílem projektu je optimalizovat algoritmus pro výpočet vln na vodě. Tento algoritmus je implementován v souboru `Ocean.cpp`, konkrétně ve funkci `updateVertices` a jejích volaných funkcích. Vaším úkolem bude vytvořit optimalizovanou verzi této funkce pomocí **SSE, AVX** nebo **AVX2**.  
+
+Kód můžete implementovat pomocí **intrinsic funkcí** (změňte v `Ocean.h` makro `ASM_TYPE` na `INTRINSIC`) nebo čistě v **GCC inline assembly** v souboru `xlogin00.s` (změňte `ASM_TYPE` na `CLEAR_ASM`).  
+
+## Struktura dat  
+
+V konstruktoru třídy `Ocean` se definují jednotlivé složky finální vlny, které se ukládají do **C++ vektoru**. Jednotlivé vlny se pak skládají do jednoho celku, přičemž s rostoucím počtem složek se zvyšuje i výpočetní náročnost.  
+
+Váš projekt by měl podporovat **1 až N složek**. Každá jednotlivá vlna (složka) je definována pomocí následující struktury:  
+
+```cpp
+struct GerstnerWave {
+    float amplitude;      // Amplituda vlny (výška)
+    float wavelength;     // Vlnová délka (vzdálenost mezi hřebeny)
+    float speed;          // Rychlost vlny
+    glm::vec2 direction;  // Směr vlny (normalizovaný 2D vektor v XZ rovině)
+    float phase;          // Fázový posun
+};
+```  
+
+## Dokumentace  
+
+V dokumentaci **podrobně popište** postup optimalizace. Pro lepší přehlednost můžete využít:  
+
+- Blokové diagramy  
+- Popisy klíčových částí kódu  
+- Vysvětlení způsobu zpracování dat  
+
+Na závěr **uveďte dosažené zrychlení**. Pokud projekt provádíte v **několika iteracích**, uveďte výkon pro jednotlivé verze.  
+
+
+## Ovládání loďky
+
+Ačkoliv to není z hlediska projektů tohoto zadání potřeba, loďku na vlnách můžete ovládat pomocí ASWD a kameru na povrch vody pomocí pravého tlačíka myši.
+
+
+## Odevzdání  
+
+Odevzdávat budete následující soubory:  
+
+- `Ocean.cpp`  
+- `Ocean.h`  
+- `xlogin00.s`  
+- `dokumentace.pdf`  
+
+## Překlad a spuštění  
+
+### Windows + VS Code  
+
+Projekt spusťte ve **VS Code** z **2. cvičení**, které obsahuje všechny potřebné knihovny.  
+
+### Linux  
+
+Překlad můžete provádět pomocí **Makefile** nebo využít VS Code soubory pro spuštění. Na Linuxu je nutné mít nainstalované následující knihovny:  
+
+Pro **Debian-based OS** (Ubuntu, Debian):  
+
+```sh
+sudo apt update
+sudo apt install freeglut3-dev libglew-dev libsoil-dev libgl-dev libglu-dev
+```

linux/.vscode/c_cpp_properties.json

@@ -0,0 +1,21 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}\\..\\include"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ],
+            "compilerPath": "${workspaceFolder}\\..\\mingw64\\bin\\g++.exe",
+            "cStandard": "c11",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "gcc-x64"
+        }
+    ],
+    "version": 4
+}

linux/.vscode/launch.json

@@ -0,0 +1,38 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "(gdb) Launch",
+        "type": "cppdbg",
+        "request": "launch",
+        "program": "boat_sim",
+        "args": [],
+        "stopAtEntry": true,
+        "cwd": "${workspaceFolder}",
+        "environment": [],
+        "externalConsole": false,
+        "preLaunchTask": "Build",
+        "windows": {
+          "MIMode": "gdb",
+          "miDebuggerPath": "gdb",
+          "setupCommands": [
+            {
+              "description": "Enable pretty-printing for gdb",
+              "text": "-enable-pretty-printing",
+              "ignoreFailures": true
+            },
+            {
+              "description": "Reduce gdb verbosity",
+              "text": "set print thread-events on",
+              "ignoreFailures": true
+            }
+          ],
+          "logging": {
+            "trace": false,
+            "traceResponse": false,
+            "engineLogging": false
+          }
+        }
+      }
+    ]
+  }

linux/.vscode/settings.json

@@ -0,0 +1,63 @@
+{
+    "files.associations": {
+        "iostream": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "semaphore": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp"
+    }
+}

linux/.vscode/tasks.json

@@ -0,0 +1,39 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build",
+            "type": "shell",
+            "command": "make", // Or "mingw32-make" if you are using MinGW on Windows and "make" is not in your PATH
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "Clean (Linux)",
+            "type": "shell",
+            "command": "make clean",
+            "args": [
+            ],
+            "problemMatcher": [],
+            "group": "cleanup",
+            "detail": "Deletes all object files (*.o) in the build"
+        },
+        {
+            "label": "Run",
+            "type": "shell",
+            "command": "boat_sim",
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "dependsOn": "Build"
+        }
+    ]
+}

linux/Makefile

@@ -0,0 +1,61 @@
+# Makefile for boat_sim project
+
+# Compiler and flags
+CXX = g++
+CXXFLAGS = -Wall -g  -mavx -msse4 # -Wall for more warnings, -g for debugging symbols
+INC_DIR = include
+LIBS = -lfreeglut -lglew32 -lSOIL -lopengl32 -lglu32
+LIB_DIR = ..\libs
+LDFLAGS = -L$(LIB_DIR)
+
+# Directories
+SRC_DIR = src
+BUILD_DIR = build
+
+# Source files - includes .cpp and .s from src and src_project
+SOURCES = $(wildcard $(SRC_DIR)/*.cpp) $(wildcard $(SRC_DIR)/src_project/*.cpp) $(wildcard $(SRC_DIR)/*.s) $(wildcard $(SRC_DIR)/src_project/*.s)
+
+# Object files in build directory - creates corresponding object file paths in build dir
+OBJECTS = $(patsubst $(SRC_DIR)/%.cpp,$(BUILD_DIR)/%.o,$(filter $(SRC_DIR)/%.cpp,$(SOURCES)))
+OBJECTS += $(patsubst $(SRC_DIR)/%.s,$(BUILD_DIR)/%.o,$(filter $(SRC_DIR)/%.s,$(SOURCES)))
+
+
+EXECUTABLE = boat_sim
+EXECUTABLE_PATH = $(EXECUTABLE)
+
+# Default target
+all: $(EXECUTABLE_PATH)
+
+# Rule to create the executable in build dir
+$(EXECUTABLE_PATH): $(OBJECTS)
+	$(CXX) -o $@ $^ $(LDFLAGS) $(LIBS)
+
+# General rule to compile/assemble source files to object files in build dir
+# For .cpp files in src directory
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.cpp
+	$(CXX) $(CXXFLAGS) -I$(INC_DIR) -c $< -o $@
+
+
+
+# For .s files in src directory - USING 'as' directly
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.s
+	$(CXX) -g -c $< -o $@ 
+
+
+
+# Clean target
+clean:
+	rm -rf $(BUILD_DIR)
+
+# Debug build target
+debug: CXXFLAGS += -DDEBUG -g
+
+# Run target
+run: all
+	./$(EXECUTABLE_PATH)
+
+# Run debug target
+rundebug: debug
+	gdb ./$(EXECUTABLE_PATH)
+
+.PHONY: all clean debug run rundebug

linux/assets/models/boat.mtl

@@ -0,0 +1,28 @@
+# 3ds Max Wavefront OBJ Exporter v0.97b - (c)2007 guruware
+# File Created: 08.06.2011 15:26:00
+
+newmtl _10634_SpeedBoat_v01_LOD310634_SpeedBoat_v01
+	Ns 53.0000
+	Ni 1.5000
+	d 1.0000
+	Tr 0.0000
+	Tf 1.0000 1.0000 1.0000 
+	illum 2
+	Ka 0.5882 0.5882 0.5882
+	Kd 0.5882 0.5882 0.5882
+	Ks 0.2000 0.2000 0.2000
+	Ke 0.0000 0.0000 0.0000
+	map_Ka boat.jpg
+	map_Kd boat.jpg
+
+newmtl glass
+	Ns 80.0000
+	Ni 1.5000
+	d 0.2000
+	Tr 0.8000
+	Tf 0.2000 0.2000 0.2000 
+	illum 2
+	Ka 0.5882 0.5882 0.5882
+	Kd 0.5882 0.5882 0.5882
+	Ks 0.5000 0.5000 0.5000
+	Ke 0.0000 0.0000 0.0000

linux/assets/shaders/ocean_fragment_shader.glsl

@@ -0,0 +1,54 @@
+#version 330 core
+// Fragment Shader for Ocean Rendering with Texture Normals
+
+in vec3 NormalInterp; // **IN variable declaration - crucial!**
+
+// Input from Vertex Shader
+in vec2 TexCoord;
+in vec3 FragPosWorld;
+in vec3 NormalWorld;
+
+// Output fragment color
+out vec4 FragColor;
+
+// Uniforms (textures, lighting parameters, camera position)
+uniform sampler2D oceanTexture;    // Sampler for ocean color texture
+uniform sampler2D normalMap;       // Sampler for normal map texture
+uniform vec3 lightDir;          // Directional light direction (world space)
+uniform vec3 lightColor;        // Light color
+uniform vec3 viewPosWorld;      // Camera position in world space
+
+void main() {
+    // 1. Sample textures
+    vec3 albedoColor = texture(oceanTexture, TexCoord).rgb; // Sample ocean color texture
+    //vec3 normalMapSample = texture(normalMap, TexCoord).rgb; // Sample normal map
+
+    // 2. Unpack and transform normal from normal map (Tangent Space to World Space - Simplified)
+    //vec3 normalMapNormal = normalize(normalMapSample * 2.0 - 1.0); // Unpack from [0, 1] to [-1, 1] and normalize
+    vec3 normalWorld = normalize(NormalInterp); // Get interpolated geometric normal from vertex shader
+
+    // **Basic Tangent Space Normal Mapping Approximation:**
+    // For truly correct tangent-space normal mapping, you'd need to construct a proper TBN matrix.
+    vec3 finalNormal = normalize(normalWorld ); // **Blend/Perturb geometric normal with texture normal**
+
+
+    // 3. Lighting calculations (Blinn-Phong example)
+    vec3 lightDirNorm = normalize(lightDir);
+    vec3 viewDirNorm = normalize(viewPosWorld - FragPosWorld);
+    vec3 reflectDir = reflect(-lightDirNorm, finalNormal);
+
+    // Diffuse component
+    float diff = max(dot(finalNormal, lightDirNorm), 0.0);
+    vec3 diffuse = diff * lightColor * albedoColor;
+
+    // Specular component (Blinn-Phong)
+    float spec = pow(max(dot(viewDirNorm, reflectDir), 0.0), 32.0);
+    vec3 specular = spec * lightColor * vec3(0.8); // Example specular color
+
+    // Ambient component
+    vec3 ambient = 0.3 * lightColor * albedoColor; // Example ambient
+
+    // 4. Combine lighting components for final color
+    vec3 finalColor = ambient + diffuse + specular;
+    FragColor = vec4(finalColor, 1.0); // Output final fragment color
+}

linux/assets/shaders/ocean_vertex_shader.glsl

@@ -0,0 +1,34 @@
+#version 330 core
+// Vertex Shader for Ocean Rendering
+
+// Input vertex attributes (from VBOs)
+layout (location = 0) in vec3 aPos;      // Vertex position (from Ocean::vertices VBO)
+layout (location = 1) in vec3 aNormal;   // Vertex normal (from Ocean::normals VBO)
+layout (location = 2) in vec2 aTexCoord; // Texture coordinates (from Ocean::texCoords VBO)
+
+// Output to Fragment Shader
+out vec2 TexCoord;
+out vec3 FragPosWorld;     // Fragment position in world space
+out vec3 NormalWorld;      // Normal vector in world space
+
+out vec3 NormalInterp; // **OUT variable declaration - crucial!**
+
+// Uniforms (matrices, light parameters, etc.)
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat3 normalMatrix; // Normal matrix for correct normal transformation
+
+void main() {
+    // 1. Transform vertex position to clip space
+    gl_Position = projection * view  * vec4(aPos, 1.0);
+
+    // 2. Pass texture coordinates to fragment shader
+    TexCoord = aTexCoord;
+
+    // 3. Calculate fragment position in world space
+    FragPosWorld = vec3(model * vec4(aPos, 1.0));
+
+    // 4. Transform normal vector to world space using the Normal Matrix
+    NormalWorld = normalize(normalMatrix * aNormal);
+}

linux/assets/shaders/terrain_fragment_shader.glsl

@@ -0,0 +1,50 @@
+#version 330 core
+// Fragment Shader for Terrain Rendering
+
+in vec3 NormalInterp; // **IN variable declaration - crucial!**
+
+
+in vec2 TexCoord;
+in vec3 FragPosWorld;
+in vec3 NormalWorld;
+
+out vec4 FragColor;
+
+uniform sampler2D terrainTexture; // Sampler for terrain color texture (no normal map for now)
+uniform sampler2D heightMapTexture; // **New: Sampler for heightmap texture**
+
+uniform vec3 lightDir;
+uniform vec3 lightColor;
+uniform vec3 viewPosWorld;
+
+void main() {
+    // 1. Sample terrain texture
+    vec3 albedoColor = texture(terrainTexture, TexCoord).rgb;
+    float heightValue = texture(heightMapTexture, TexCoord).r; // **Sample heightmap (Red channel = grayscale height)**
+
+    // 2. Lighting calculations (Blinn-Phong - similar to ocean shader)
+    vec3 normal = normalize(NormalWorld); // Use geometric normal for terrain
+    vec3 lightDirNorm = normalize(lightDir);
+    vec3 viewDirNorm = normalize(viewPosWorld - FragPosWorld);
+    vec3 reflectDir = reflect(-lightDirNorm, normal);
+
+    // Diffuse component
+    float diff = max(dot(normal, lightDirNorm), 0.0);
+    vec3 diffuse = diff * lightColor * albedoColor;
+
+    // Specular component
+    float spec = pow(max(dot(viewDirNorm, reflectDir), 0.0), 16.0); // Adjust shininess (exponent)
+    vec3 specular = spec * lightColor * vec3(0.3); // Example specular color - less shiny than ocean
+
+    // Ambient component
+    vec3 ambient = 0.2 * lightColor * albedoColor;
+
+    vec3 lowColor = vec3(0.2, 0.3, 0.05); // Darker green/brown for lower areas
+    vec3 highColor = vec3(0.5, 0.7, 0.2); // Lighter green for higher areas
+    vec3 heightBasedColor = mix(lowColor, highColor, heightValue); // Linear interpolation based on heightValue
+
+
+    // 4. Combine lighting components for final color
+    vec3 finalColor = ambient + diffuse + specular;
+    FragColor = vec4(finalColor * heightBasedColor, 1.0);
+}

linux/assets/shaders/terrain_vertex_shader.glsl

@@ -0,0 +1,22 @@
+#version 330 core
+// Vertex Shader for Terrain Rendering
+
+layout (location = 0) in vec3 aPos;      // Vertex position
+layout (location = 1) in vec3 aNormal;   // Vertex normal
+layout (location = 2) in vec2 aTexCoord; // Texture coordinates
+
+out vec2 TexCoord;
+out vec3 FragPosWorld;
+out vec3 NormalWorld;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat3 normalMatrix;
+
+void main() {
+    gl_Position = projection * view  * vec4(aPos, 1.0);
+    TexCoord = aTexCoord;
+    FragPosWorld = vec3(model * vec4(aPos, 1.0));
+    NormalWorld = normalize(normalMatrix * aNormal);
+}

linux/include/Boat.h

@@ -0,0 +1,66 @@
+#ifndef BOAT_H
+#define BOAT_H
+
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <vector>
+#include "Input.h"
+#include "Ocean.h"
+#include <string>
+#include <tiny_obj_loader.h> // Include tinyobjloader
+
+class Boat {
+public:
+    Boat();
+    ~Boat();
+
+    bool init(const char* modelPath, const char* texturePath); // Pass model and texture paths
+    void cleanup();
+    void update(const Input& input, const Ocean& ocean, float deltaTime);
+
+    glm::vec3 getPosition() const { return position; }
+    glm::quat getRotation() const { return rotation; }
+
+    glm::vec3 getBoundingBoxMin() const { return boundingBoxMin; } // **Getter for boundingBoxMin**
+    glm::vec3 getBoundingBoxMax() const { return boundingBoxMax; } // **Getter for boundingBoxMax**
+
+    // Getters for model data to pass to Renderer
+    const std::vector<glm::vec3>& getVertices() const { return vertices; }
+    const std::vector<glm::vec3>& getNormals() const { return normals; }
+    const std::vector<glm::vec2>& getTexCoords() const { return texCoords; }
+    const std::string& getTexturePath() const { return boatTexturePath; } // Getter for texture path
+    const std::vector<tinyobj::material_t>& getMaterials() const { return materials; } // Getter for materials
+    const std::vector<int>& getMaterialIndices() const { return materialIndices; } // Getter for materials
+
+    // New: Getter and Setter for boatScale
+    float getScale() const { return boatScale; }
+    void setScale(float scale) { boatScale = scale; }
+
+
+private:
+    glm::vec3 position;
+    glm::quat rotation;
+    float speed;
+    float steeringSpeed;
+
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec3> normals;
+    std::vector<glm::vec2> texCoords;
+    std::vector<int> materialIndices; // New: Store material indices per vertex
+    std::vector<tinyobj::material_t> materials; // New: Store materials
+
+
+    void handleInput(const Input& input, float deltaTime);
+    void applyWaveMotion(const Ocean& ocean);
+    bool loadModel(const char* path); // Function to load OBJ model
+    std::string boatTexturePath; // Store texture path for Renderer to access
+    glm::vec3 boundingBoxMin;
+    glm::vec3 boundingBoxMax;
+    int getGridIndex(int x, int z) const;         // Helper function to get 1D index from 2D grid indices
+
+    float boatScale;
+
+
+};
+
+#endif // BOAT_H

linux/include/Camera.h

@@ -0,0 +1,41 @@
+// Camera.h
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include <glm/glm.hpp>
+#include "Input.h" // Optional Shader class
+
+class Camera {
+public:
+    Camera();
+    ~Camera();
+
+    void init();
+    void update(const Input& input, const glm::vec3& boatPosition);
+    void lookAt() const;
+
+    void setAspectRatio(float ratio) { aspectRatio = ratio; }
+    glm::vec3 getPosition() const { return position; } // Public getter for position
+    glm::mat4 getViewMatrix() const; // **Declare getViewMatrix() method**
+
+        // New: Camera Rotation Control
+        void handleMouseInput(const Input& input, float deltaTime);
+        void rotateYaw(float angle);
+        void rotatePitch(float angle);
+private:
+    glm::vec3 position;
+    glm::vec3 target; // Point to look at
+    glm::vec3 up;
+    float aspectRatio;
+    float fov;
+    float nearPlane;
+    float farPlane;
+
+
+    // New: Camera Rotation State
+    float yawAngle=0.0f;
+    float pitchAngle=0.0f;
+    float rotationSpeed;
+};
+
+#endif // CAMERA_H

linux/include/Game.h

@@ -0,0 +1,47 @@
+// Game.h
+#ifndef GAME_H
+#define GAME_H
+#include <GL/glew.h>
+#include <GL/freeglut.h>
+#include "Renderer.h"
+#include "Input.h"
+#include "Ocean.h"
+#include "Boat.h"
+#include "Camera.h"
+#include <cstdio>
+#include <iostream>
+#include "Terrain.h" // Include Terrain header
+
+class Game {
+public:
+    Game();
+    ~Game();
+
+    bool init(int argc, char** argv);
+    void run();
+    void cleanup();
+
+private:
+    Renderer renderer;
+    Input input;
+    Ocean ocean;
+    Boat boat;
+    Camera camera;
+    Terrain terrain; // Add Terrain member
+
+
+    static void displayCallback();
+    static void reshapeCallback(int width, int height);
+    static void keyboardCallback(unsigned char key, int x, int y);
+    static void keyboardUpCallback(unsigned char key, int x, int y);
+    static void specialCallback(int key, int x, int y);
+    static void specialUpCallback(int key, int x, int y);
+    static void mouseCallback(int button, int state, int x, int y);
+    static void motionCallback(int x, int y);
+    static void timerCallback(int value);
+    static void updateGame();
+
+    static Game* instance; // Singleton for callbacks to access game instance
+};
+
+#endif // GAME_H

linux/include/Input.h

@@ -0,0 +1,45 @@
+// Input.h
+#ifndef INPUT_H
+#define INPUT_H
+
+#include <set>
+
+class Input {
+public:
+    Input();
+    ~Input();
+
+    void init();
+    void update();
+
+    void handleKeyPress(unsigned char key);
+    void handleKeyRelease(unsigned char key);
+    void handleSpecialKeyPress(int key);
+    void handleSpecialKeyRelease(int key);
+    void handleMouseClick(int button, int state, int x, int y);
+    void handleMouseMove(int x, int y);
+
+    bool isKeyDown(unsigned char key) const;
+    bool isSpecialKeyDown(int key) const;
+    // Mouse input methods if needed
+
+    // New: Mouse Input Methods
+    bool isMouseButtonDown(int button) const { return mouseButtonsDown[button]; }
+    int getMouseX() const { return mouseX; }
+    int getMouseY() const { return mouseY; }
+    int getMouseDeltaX() const { return mouseDeltaX; }
+    int getMouseDeltaY() const { return mouseDeltaY; }
+
+
+private:
+    std::set<unsigned char> keysDown;
+    std::set<int> specialKeysDown;
+    // Mouse state variables if needed
+
+        bool mouseButtonsDown[5]; // Up to 5 mouse buttons (GLUT_LEFT_BUTTON, etc.)
+    int mouseX, mouseY;        // Current mouse position
+    int lastMouseX, lastMouseY; // Last frame's mouse position
+    int mouseDeltaX, mouseDeltaY; // Mouse movement delta since last frame
+};
+
+#endif // INPUT_H

linux/include/Ocean.h

@@ -0,0 +1,94 @@
+// Ocean.h
+#ifndef OCEAN_H
+#define OCEAN_H
+
+#include <glm/glm.hpp>
+#include <vector>
+#include <GL/glew.h> // Include GLEW for OpenGL types like GLuint
+#include "utils.h" // **Include utils.h to use checkGLError**
+#include <immintrin.h>
+#include <x86intrin.h>
+
+
+
+#define ASM_TYPE CLEAR_ASM
+
+
+#define INTRINSIC 1
+#define CLEAR_ASM 2
+
+
+// Structure to hold parameters for a single Gerstner wave component
+struct GerstnerWave {
+    float amplitude;    // Wave amplitude (height)
+    float wavelength;   // Wavelength (distance between crests)
+    float speed;        // Wave speed
+    glm::vec2 direction; // Wave direction (normalized 2D vector in XZ plane)
+    float phase;        // Phase offset
+};
+
+
+class Ocean {
+public:
+    Ocean(int gridSize);
+    ~Ocean();
+
+    bool init();
+    void cleanup();
+    void update(float deltaTime);
+
+    glm::vec3 getVertex(int x, int z) const;
+    float getWaveHeight(float x, float z, float time) const;
+    glm::vec3 getWaveNormal(float x, float z, float time) const; // Calculate wave normal
+
+    void setGridSize(int newGridSize); // Setter function
+    int getGridSize() const { return gridSize; }
+    float getGridSpacing() const { return gridSpacing; }
+    GLuint getVAO() const;                                // Get the Vertex Array Object ID
+    GLuint getIndexCount() const;                         // Get the number of indices for rendering
+    float time;
+
+
+private:
+    int gridSize;
+    float gridSpacing;
+    std::vector<glm::vec3> vertices; // Store vertices for optimization (optional)
+    std::vector<GerstnerWave> gerstnerWaves; // Vector to store multiple Gerstner wave components
+
+    // Wave parameters (adjustable)
+    float amplitude;
+    float wavelength;
+    float frequency;
+    glm::vec2 direction; // Wave direction
+    float phase; // Initial phase
+
+
+    GLuint vertexBufferID;    // VBO ID for vertex positions
+    GLuint normalBufferID;    // VBO ID for vertex normals
+    GLuint texCoordBufferID;  // VBO ID for texture coordinates
+    GLuint indexBufferID;     // IBO ID for indices
+    GLuint vaoID;             // VAO ID (Vertex Array Object)
+    unsigned int indexCount;    // Number of indices for rendering
+
+    std::vector<float> originalWorldX;        // Vector to store original undisplaced World X coordinates
+    std::vector<float> originalWorldZ;        // Vector to store original undisplaced World Z coordinates
+
+    float baseAmplitude;  // Base (maximum) wave amplitude for periodic modulation
+
+
+    void generateGrid();
+    void createBuffers();                        // Create and populate VBOs and IBO
+    void updateBuffers(const std::vector<glm::vec3>& updatedVertices, const std::vector<glm::vec3>& updatedNormals); // Update VBO data
+    void updateVertices(std::vector<glm::vec3> * updatedVertices, std::vector<glm::vec3> * updatedNormals, float time); // Update vertex Y positions based on wave function
+    
+#if ASM_TYPE==CLEAR_ASM
+#else
+    void updateVertices_simd(float* updatedVertices_array, float* updatedNormals_array, size_t numVertices, float time); // Modified signature for C++ as well (for consistency or if you want to use float arrays in C++ SIMD too)
+#endif
+    
+    int getGridIndex(int x, int z) const;         // Helper function to get 1D index from 2D grid indices
+    float getGerstnerWaveHeight(const GerstnerWave& wave, float x, float z, float time) const; // Calculate height for a single Gerstner wave
+    glm::vec3 getGerstnerWaveDisplacement(const GerstnerWave& wave, float x, float z, float time) const; // Calculate horizontal displacement for a Gerstner wave
+};
+
+#endif // OCEAN_H

linux/include/Renderer.h

@@ -0,0 +1,53 @@
+// Renderer.h
+#ifndef RENDERER_H
+#define RENDERER_H
+
+#include <GL/glew.h>
+#include <GL/freeglut.h>
+#include "Ocean.h"
+#include "Boat.h"
+#include "Camera.h"
+#include "Shader.h" // Optional Shader class
+#include "Terrain.h" // Include Terrain header
+
+
+#define SHOW_GRID 0
+#define SHOW_NORM 0
+#define SHOW_BOUDING_BOX 1
+
+class Renderer {
+public:
+    Renderer();
+    ~Renderer();
+    GLuint oceanTextureID;
+    GLuint boatTextureID;
+    GLuint terrainTextureID; // Texture ID for terrain
+    GLuint heightMapTextureID; // **Add heightMapTextureID**
+    bool init();
+    void cleanup();
+    void renderScene(const Ocean &ocean, const Boat &boat, const Camera &camera, const Terrain &Terrain);
+    void reshape(int width, int height);
+    void drawOcean(const Ocean& ocean, const Camera& camera); // Camera argument added
+    GLuint getTerrainTextureID() const { return terrainTextureID; } // Getter for terrain texture ID
+
+private:
+
+    // Shader shaderProgram; // Optional shader program
+    GLuint normalMapTextureID; 
+    Shader oceanShader; // Shader program for ocean
+    Shader terrainShader; // **Add terrainShader member variable**
+
+    std::string lastBoatTexturePath = "";
+
+    bool loadTexture(const char* filename, GLuint& textureID);
+    void setupLighting();
+    void drawBoat(const Boat& boat);
+    void drawMesh(const std::vector<glm::vec3>& vertices, const std::vector<glm::vec3>& normals, const std::vector<glm::vec2>& texCoords,
+                  const std::vector<int>& materialIndices, const std::vector<tinyobj::material_t>& materials); // Modified drawMesh
+
+    void drawMeshVBO(const Ocean& ocean); // **Declare drawMeshVBO**
+    void drawTerrain(const Terrain& terrain, const Camera& camera);
+    void drawMeshTerainVBO(const Terrain& terrain);
+};
+
+#endif // RENDERER_H

linux/include/Shader.h

@@ -0,0 +1,39 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+#include <string>
+#include <GL/glew.h> // Include GLEW for OpenGL types
+#include <glm/glm.hpp> // **ADD THIS LINE - Include GLM header!**
+#include <glm/gtc/type_ptr.hpp>
+
+
+
+class Shader {
+public:
+    Shader(); // Constructor
+    ~Shader(); // Destructor
+
+    bool loadShader(const char* vertexShaderPath, const char* fragmentShaderPath); // Load and compile shaders from files
+    bool isLoaded() const { return programID != 0; } // Check if shader program is loaded
+
+    void use();       // Use (activate) the shader program
+    void unuse();     // Unuse (deactivate) the shader program
+    void cleanup();   // Release shader resources
+
+    // Uniform setting functions (add more as needed for different uniform types)
+    void setInt(const std::string& name, int value) const;
+    void setFloat(const std::string& name, float value) const;
+    void setVec3(const std::string& name, const glm::vec3& value) const;
+    void setMat4(const std::string& name, const glm::mat4& mat) const;
+    void setMat3(const std::string& name, const glm::mat3& mat) const;
+
+private:
+    GLuint vertexShaderID;   // Vertex shader object ID
+    GLuint fragmentShaderID; // Fragment shader object ID
+    GLuint programID;        // Shader program ID
+
+    bool compileShader(GLuint& shaderID, GLenum shaderType, const char* shaderPath);
+    bool linkShaderProgram();
+};
+
+#endif // SHADER_H

linux/include/Terrain.h

@@ -0,0 +1,43 @@
+// include/Terrain.h
+#ifndef TERRAIN_H
+#define TERRAIN_H
+
+#include <glm/glm.hpp>
+#include <vector>
+#include <GL/glew.h> // Include GLEW for OpenGL types like GLuint
+#include "Shader.h"
+class Terrain {
+public:
+    Terrain(int gridSize, float gridSpacing);
+    ~Terrain();
+
+    bool init(GLuint heightMapTextureID);
+    void cleanup();
+
+    glm::vec3 getVertex(int x, int z) const; // Get vertex position at grid index (x, z)
+
+    int getGridSize() const { return gridSize; }
+    float getGridSpacing() const { return gridSpacing; }
+    GLuint getVAO() const { return vaoID; }
+    GLuint getIndexCount() const { return indexCount; }
+    glm::vec3 getNormal(float x, float z) const;
+private:
+    int gridSize;
+    float gridSpacing;
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec3> normals;
+    std::vector<glm::vec2> texCoords;
+    GLuint vertexBufferID;
+    GLuint normalBufferID;
+    GLuint texCoordBufferID;
+    GLuint indexBufferID;
+    GLuint vaoID;
+    unsigned int indexCount;
+
+
+    void generateGrid(GLuint heightMapTextureID); // Generate the initial grid of vertices
+    void createBuffers(); // Create and populate VBOs and IBO
+    void updateBuffers();   // Update VBO data (not needed for static terrain in this example, but good to have)
+};
+
+#endif // TERRAIN_H

linux/include/utils.h

@@ -0,0 +1,15 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <GL/glew.h>
+#include <iostream>
+#include <glm/glm.hpp>
+#include <x86intrin.h>
+
+
+// Helper function to check for OpenGL errors and print a message
+void checkGLError(const char* operation);
+float perlinNoise(float x, float y); // Placeholder declaration
+
+uint64_t rdtsc();
+#endif // UTILS_H

linux/src/Boat.cpp

@@ -0,0 +1,215 @@
+/*
+ * File:        Boat.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Class for representng boat
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+
+
+#include "Boat.h"
+#include <iostream>
+#define TINYOBJLOADER_IMPLEMENTATION
+#include <tiny_obj_loader.h> // Include tinyobjloader
+#include <glm/gtc/type_ptr.hpp> // For value_ptr (if needed for debugging)
+
+Boat::Boat() : position(0.0f, 0.5f, 0.0f), rotation(glm::quat(1.0f, 0.0f, 0.0f, 0.0f)), speed(0.0f), steeringSpeed(1.0f), materials(), boatScale(1.0f) {} // Initialize boatScale to 1.0f
+Boat::~Boat() {}
+
+bool Boat::init(const char* modelPath, const char* texturePath) {
+    materials.clear(); // Explicitly clear materials before loading model
+    if (!loadModel(modelPath)) {
+        std::cerr << "Error loading boat model: " << modelPath << std::endl;
+        return false;
+    }
+    boatTexturePath = texturePath;
+    return true;
+}
+
+void Boat::cleanup() {
+    // No dynamic memory cleanup in this simple example, but if you used dynamic allocation in loadModel, clean it up here.
+}
+
+void Boat::update(const Input& input, const Ocean& ocean, float deltaTime) {
+    handleInput(input, deltaTime);
+    applyWaveMotion(ocean);
+}
+
+void Boat::handleInput(const Input& input, float deltaTime) {
+    if (input.isKeyDown('w')) {
+        speed += 0.5f * deltaTime; // Accelerate forward
+    }
+    if (input.isKeyDown('s')) {
+        speed -= 0.5f * deltaTime; // Decelerate/reverse
+    }
+    if (input.isKeyDown('a')) {
+        rotation = glm::rotate(rotation, steeringSpeed * deltaTime, glm::vec3(0.0f, 1.0f, 0.0f)); // Steer left
+    }
+    if (input.isKeyDown('d')) {
+        rotation = glm::rotate(rotation, -steeringSpeed * deltaTime, glm::vec3(0.0f, 1.0f, 0.0f)); // Steer right
+    }
+
+    speed = glm::clamp(speed, -0.5f, 4.0f); // Clamp speed
+    if (!input.isKeyDown('w') && !input.isKeyDown('s')) {
+        speed *= (1.0f - 0.5f * deltaTime); // Natural deceleration
+        if (fabs(speed) < 0.01f) speed = 0.0f; // Stop completely
+    }
+
+    // Move boat forward/backward based on rotation and speed
+    glm::vec3 forwardVector = rotation * glm::vec3(0.0f, 0.0f, -1.0f); // Boat's forward direction
+    position += forwardVector * speed * deltaTime;
+}
+
+void Boat::applyWaveMotion(const Ocean& ocean) {
+    // Sample wave height at boat's position
+    position.y = ocean.getWaveHeight(position.x, position.z, ocean.time);
+
+    // Get wave normal
+    glm::vec3 waveNormal = ocean.getWaveNormal(position.x, position.z, ocean.time);
+    //std::cout << "Wave Normal: (" << waveNormal.x << ", " << waveNormal.y << ", " << waveNormal.z << ")" << std::endl;
+
+    // Get current boat forward direction
+    glm::vec3 currentBoatForward = rotation * glm::vec3(0.0f, 0.0f, -1.0f);
+    glm::vec3 horizontalForward = glm::normalize(glm::vec3(currentBoatForward.x, 0.0f, currentBoatForward.z));
+    if (horizontalForward == glm::vec3(0.0f)) {
+        horizontalForward = glm::vec3(0.0f, 0.0f, -1.0f); // Default if boat is pointing straight up/down
+    }
+
+    glm::vec3 targetUp = waveNormal;
+    glm::vec3 targetForward = glm::normalize(glm::cross(glm::cross(targetUp, horizontalForward), targetUp)); // Project horizontalForward onto plane perpendicular to targetUp
+
+    if (targetForward == glm::vec3(0.0f)) {
+        targetForward = horizontalForward; // Fallback if projection fails (waveNormal is vertical or horizontalForward is parallel to waveNormal somehow)
+    }
+
+    glm::vec3 targetRight = glm::normalize(glm::cross(targetForward, targetUp));
+
+    // Create rotation matrix from basis vectors
+    glm::mat3 targetRotationMatrix(targetRight, targetUp, -targetForward); // Boat forward is -Z
+    glm::quat targetRotation = glm::quat_cast(targetRotationMatrix);
+
+    rotation = glm::slerp(rotation, targetRotation, 0.1f);
+}
+
+
+bool Boat::loadModel(const char* path) {
+    tinyobj::attrib_t attrib;
+    std::vector<tinyobj::shape_t> shapes;
+    std::vector<tinyobj::material_t> materials;
+    std::string warn, err;
+
+    // Extract the directory path from the OBJ file path
+    std::string inputfile_dir = "./";
+    std::string path_str = path;
+    size_t last_slash_pos = path_str.find_last_of("/\\"); // Handle both / and \ path separators
+    if (last_slash_pos != std::string::npos) {
+        inputfile_dir = path_str.substr(0, last_slash_pos + 1); // Include the last slash
+    }
+
+    bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path, inputfile_dir.c_str()); // Pass mtl_basepath
+
+    if (!warn.empty()) {
+        std::cout << "tinyobjloader warning: " << warn << std::endl;
+    }
+
+    if (!err.empty()) {
+        std::cerr << "tinyobjloader error: " << err << std::endl;
+    }
+
+    if (!ret) {
+        return false;
+    }
+
+    vertices.clear();
+    normals.clear();
+    texCoords.clear();
+    materialIndices.clear(); // Clear material indices
+    // Loop through each shape in the OBJ file
+    for (const auto& shape : shapes) {
+        // Loop over faces(polygon)
+        for (size_t f = 0; f < shape.mesh.indices.size() / 3; f++) {
+            int material_index = shape.mesh.material_ids[f]; // Get material index for this face
+
+            // Loop over vertices in the face (triangle)
+            for (size_t v = 0; v < 3; v++) {
+                tinyobj::index_t idx = shape.mesh.indices[3 * f + v];
+
+                tinyobj::real_t vx = attrib.vertices[3 * idx.vertex_index + 0];
+                tinyobj::real_t vy = attrib.vertices[3 * idx.vertex_index + 1];
+                tinyobj::real_t vz = attrib.vertices[3 * idx.vertex_index + 2];
+                vertices.push_back(glm::vec3(vx, vy, vz));
+
+                if (!attrib.normals.empty()) {
+                    tinyobj::real_t nx = attrib.normals[3 * idx.normal_index + 0];
+                    tinyobj::real_t ny = attrib.normals[3 * idx.normal_index + 1];
+                    tinyobj::real_t nz = attrib.normals[3 * idx.normal_index + 2];
+                    normals.push_back(glm::vec3(nx, ny, nz));
+                } else {
+                    normals.push_back(glm::vec3(0.0f, 1.0f, 0.0f)); // Default normal if no normals in OBJ
+                }
+
+                if (!attrib.texcoords.empty()) {
+                    tinyobj::real_t tx = attrib.texcoords[2 * idx.texcoord_index + 0];
+                    tinyobj::real_t ty = attrib.texcoords[2 * idx.texcoord_index + 1];
+                    texCoords.push_back(glm::vec2(tx, 1.0f - ty)); // Flip V texture coord (OpenGL convention)
+                } else {
+                    texCoords.push_back(glm::vec2(0.0f, 0.0f)); // Default texcoord if no texcoords in OBJ
+                }
+                materialIndices.push_back(material_index); // Store material index for this vertex
+            }
+        }
+    }
+
+    if (ret) {
+
+        glm::quat modelRotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f); // Identity quaternion (no rotation initially)
+
+        // **Experiment with these rotations to find the correct orientation!**
+        // Example 1: Rotate 180 degrees around Y-axis (to flip the boat horizontally if it's backwards)
+        modelRotation = glm::rotate(modelRotation, glm::radians(180.0f), glm::vec3(0.0f, 1.0f, 0.0f)); // Rotate 180 degrees yaw
+        modelRotation = glm::rotate(modelRotation, glm::radians(180.f), glm::vec3(1.0f, 0.0f, 0.0f)); // Yaw rotation (example: 0 degrees)
+        modelRotation = glm::rotate(modelRotation, glm::radians(90.0f), glm::vec3(1.0f, 0.0f, 0.0f)); // Pitch rotation (example: 0 degrees)
+        // Example 2: Rotate around X-axis (Pitch) - Adjust angle as needed
+        // modelRotation = glm::rotate(modelRotation, glm::radians(0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); // No pitch rotation in this example
+
+        // Example 3: Rotate around Z-axis (Roll) - Adjust angle as needed
+        // modelRotation = glm::rotate(modelRotation, glm::radians(0.0f), glm::vec3(0.0f, 0.0f, 1.0f)); // No roll rotation in this example
+
+
+        // **Apply rotation to vertices AFTER model loading**
+        for (glm::vec3& vertex : vertices) {
+            vertex = modelRotation * vertex; // Apply rotation to each vertex in model space
+        }
+
+
+
+
+
+        // **Calculate Bounding Box AFTER model loading**
+        if (!vertices.empty()) {
+            boundingBoxMin = vertices[0]; // Initialize with first vertex
+            boundingBoxMax = vertices[0];
+            std::cout << "Boat Bounding Box Min: (" << boundingBoxMin.x << ", " << boundingBoxMin.y << ", " << boundingBoxMin.z << ")" << std::endl;
+
+            // **Bounding Box Calculation Loop - This is where boundingBoxMin and boundingBoxMax are calculated and set**
+            for (const auto& vertex : vertices) {
+                boundingBoxMin.x = glm::min(boundingBoxMin.x, vertex.x);
+                boundingBoxMin.y = glm::min(boundingBoxMin.y, vertex.y);
+                boundingBoxMin.z = glm::min(boundingBoxMin.z, vertex.z);
+
+                boundingBoxMax.x = glm::max(boundingBoxMax.x, vertex.x);
+                boundingBoxMax.y = glm::max(boundingBoxMax.y, vertex.y);
+                boundingBoxMax.z = glm::max(boundingBoxMax.z, vertex.z);
+            }
+            std::cout << "Boat Bounding Box Min: (" << boundingBoxMin.x << ", " << boundingBoxMin.y << ", " << boundingBoxMin.z << ")" << std::endl;
+            std::cout << "Boat Bounding Box Max: (" << boundingBoxMax.x << ", " << boundingBoxMax.y << ", " << boundingBoxMax.z << ")" << std::endl;
+
+        }
+    }
+
+    return ret;
+}

linux/src/Camera.cpp

@@ -0,0 +1,83 @@
+/*
+ * File:        Camera.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Camera
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "Camera.h"
+#include <GL/freeglut.h>
+#include <glm/gtc/matrix_transform.hpp>
+
+Camera::Camera() : position(10.0f, 10.0f, 10.0f), target(0.0f, 0.0f, 0.0f), up(0.0f, 1.0f, 0.0f),
+                   aspectRatio(1.0f), fov(45.0f), nearPlane(0.1f), farPlane(100.0f) {}
+
+Camera::~Camera() {}
+
+void Camera::init() {
+    // Initial camera setup if needed
+}
+
+void Camera::update(const Input& input, const glm::vec3& boatPosition) {
+    target = boatPosition;
+
+    glm::vec3 lookDirection;
+    lookDirection.x = cos(glm::radians(pitchAngle)) * cos(glm::radians(yawAngle));
+    lookDirection.y = sin(glm::radians(pitchAngle));
+    lookDirection.z = cos(glm::radians(pitchAngle)) * sin(glm::radians(yawAngle));
+    lookDirection = glm::normalize(lookDirection);
+
+    position = target - lookDirection * glm::vec3(10.0f); // **Update position here in update**
+    position.y = glm::max(position.y, 2.0f);
+
+    //position = boatPosition + glm::vec3(5.0f, 5.0f, 5.0f); // Offset from boat
+    //position.y = glm::max(position.y, 2.0f); // Keep camera above water
+
+    up = glm::vec3(0.0f, 1.0f, 0.0f);    
+
+    glm::vec3 forward = glm::normalize(target - position);
+    glm::vec3 right = glm::normalize(glm::cross(forward, up));
+    // Recalculate up to ensure orthogonality (important for gluLookAt)
+    up = glm::normalize(glm::cross(right, forward));
+
+    handleMouseInput(input, 1.0f/60.0f); // Example deltaTime (fixed 60fps for now) 
+}
+
+void Camera::lookAt() const {
+    gluLookAt(position.x, position.y, position.z,
+              target.x, target.y, target.z,
+              up.x, up.y, up.z);
+}
+
+glm::mat4 Camera::getViewMatrix() const { // Keep `const` method
+    // Recalculate camera position and up vector based on yawAngle and pitchAngle
+
+
+    // **Calculate view matrix based on CURRENT position, target, up - NO MODIFICATION of members in getViewMatrix**
+    return glm::lookAt(position, target, up); // Use current position, target, up
+}
+
+
+void Camera::handleMouseInput(const Input& input, float deltaTime) {
+    if (input.isMouseButtonDown(GLUT_RIGHT_BUTTON)) { // Rotate only when right mouse button is pressed
+        float mouseSensitivity = 0.1f; // Adjust sensitivity
+        yawAngle   += input.getMouseDeltaX() * mouseSensitivity;
+        pitchAngle -= input.getMouseDeltaY() * mouseSensitivity; // Invert vertical mouse motion
+
+        // Clamp pitch angle to prevent camera flipping
+        pitchAngle = glm::clamp(pitchAngle, -89.0f, 89.0f);
+
+    }
+}
+
+void Camera::rotateYaw(float angle) {
+    yawAngle += angle;
+}
+
+void Camera::rotatePitch(float angle) {
+    pitchAngle += angle;
+}

linux/src/Game.cpp

@@ -0,0 +1,137 @@
+/*
+ * File:        Game.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class integrates all items into the game world.
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Game.h"
+
+Game* Game::instance = nullptr;
+
+Game::Game() : renderer(), input(), ocean(200), boat(), camera(), terrain(150, 1.0f)  {
+    instance = this;
+}
+
+Game::~Game() {
+    instance = nullptr;
+}
+
+bool Game::init(int argc, char** argv) {
+    glutInit(&argc, argv);
+    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
+    glutInitWindowSize(1200, 800);
+    glutCreateWindow("3D Boat Simulation");
+
+    // **Initialize GLEW AFTER creating the window:**
+    if (glewInit() != GLEW_OK) {
+        //std::cerr << "GLEW initialization failed!" << std::endl;
+        return false;
+    }
+
+
+
+    glutDisplayFunc(displayCallback);
+    glutReshapeFunc(reshapeCallback);
+    glutKeyboardFunc(keyboardCallback);
+    glutKeyboardUpFunc(keyboardUpCallback);
+    glutSpecialFunc(specialCallback);
+    glutSpecialUpFunc(specialUpCallback);
+    glutMouseFunc(mouseCallback);
+    glutMotionFunc(motionCallback);
+    glutTimerFunc(16, timerCallback, 0); // ~60 FPS
+
+    glEnable(GL_DEPTH_TEST);
+    renderer.init();
+    //int oceanGridSize = 1000; // Default gridSize (you can change this)
+    //ocean = Ocean(oceanGridSize); // Pass gridSize to constructor
+    ocean.init();
+
+    if (!boat.init("assets/models/boat.obj", "assets/models/boat.jpg")) {
+        std::cerr << "Boat initialization failed!" << std::endl;
+        return false;
+    }
+    boat.setScale(0.01f); // Example: Make the boat half its original size
+
+
+
+
+    std::cerr << "Terrain init" << std::endl;
+
+    // Initialize Terrain
+    if (!terrain.init(renderer.heightMapTextureID)) {
+        std::cerr << "Terrain initialization failed!" << std::endl;
+        return false;
+    }
+    std::cerr << "Camera init" << std::endl;
+
+    camera.init();
+    std::cerr << "Input init" << std::endl;
+
+    input.init();
+    return true;
+}
+
+void Game::run() {
+    glutMainLoop();
+}
+
+void Game::cleanup() {
+    renderer.cleanup();
+    ocean.cleanup();
+    boat.cleanup();
+    terrain.cleanup(); // Cleanup terrain
+
+}
+
+void Game::displayCallback() {
+    instance->renderer.renderScene(instance->ocean, instance->boat, instance->camera, instance->terrain); // **Pass instance->terrain**
+        glutSwapBuffers();
+}
+
+void Game::reshapeCallback(int width, int height) {
+    instance->renderer.reshape(width, height);
+    instance->camera.setAspectRatio(static_cast<float>(width) / height);
+}
+
+void Game::keyboardCallback(unsigned char key, int x, int y) {
+    instance->input.handleKeyPress(key);
+}
+
+void Game::keyboardUpCallback(unsigned char key, int x, int y) {
+    instance->input.handleKeyRelease(key);
+}
+
+void Game::specialCallback(int key, int x, int y) {
+    instance->input.handleSpecialKeyPress(key);
+}
+
+void Game::specialUpCallback(int key, int x, int y) {
+    instance->input.handleSpecialKeyRelease(key);
+}
+
+void Game::mouseCallback(int button, int state, int x, int y) {
+    instance->input.handleMouseClick(button, state, x, y);
+}
+
+void Game::motionCallback(int x, int y) {
+    instance->input.handleMouseMove(x, y);
+}
+
+void Game::updateGame() {
+    float deltaTime = 1.0f / 60.0f; // Fixed timestep for simplicity
+    instance->input.update();
+    instance->boat.update(instance->input, instance->ocean, deltaTime);
+    instance->camera.update(instance->input, instance->boat.getPosition()); // Camera follows boat (optional)
+    instance->ocean.update(deltaTime);
+}
+
+void Game::timerCallback(int value) {
+    instance->updateGame();
+    glutTimerFunc(16, timerCallback, 0); // Re-register timer
+    glutPostRedisplay(); // Request redraw
+}
+

linux/src/Input.cpp

@@ -0,0 +1,65 @@
+/*
+ * File:        Input.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class defines the game inputs.
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "Input.h"
+#include <GL/freeglut.h>
+#include <cstring>
+Input::Input() {
+    memset(mouseButtonsDown, false, sizeof(mouseButtonsDown)); // Initialize mouse button states to false
+    mouseX = mouseY = lastMouseX = lastMouseY = 0;
+    mouseDeltaX = mouseDeltaY = 0;
+}
+Input::~Input() {}
+
+void Input::init() {}
+void Input::update() {
+    // Calculate mouse delta
+    mouseDeltaX = mouseX - lastMouseX;
+    mouseDeltaY = mouseY - lastMouseY;
+
+    // Update last mouse positions for next frame
+    lastMouseX = mouseX;
+    lastMouseY = mouseY;
+}
+void Input::handleKeyPress(unsigned char key) {
+    keysDown.insert(key);
+}
+
+void Input::handleKeyRelease(unsigned char key) {
+    keysDown.erase(key);
+}
+
+void Input::handleSpecialKeyPress(int key) {
+    specialKeysDown.insert(key);
+}
+
+void Input::handleSpecialKeyRelease(int key) {
+    specialKeysDown.erase(key);
+}
+
+void Input::handleMouseClick(int button, int state, int x, int y) {
+    if (button >= 0 && button < 5) { // Check button index is within range
+        mouseButtonsDown[button] = (state == GLUT_DOWN);
+    }
+}
+
+void Input::handleMouseMove(int x, int y) {
+    mouseX = x;
+    mouseY = y;
+}
+
+bool Input::isKeyDown(unsigned char key) const {
+    return keysDown.count(key);
+}
+
+bool Input::isSpecialKeyDown(int key) const {
+    return specialKeysDown.count(key);
+}

linux/src/Ocean.cpp

@@ -0,0 +1,403 @@
+/*
+ * File:        Ocean.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class defines ocean (surface). The core functions of this class are optimized by the IPA Project 2025.
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Ocean.h"
+#include <cmath>
+#include <glm/gtc/constants.hpp> // For pi
+#include <chrono>
+
+
+
+#if ASM_TYPE==CLEAR_ASM
+    // Assembly version declaration (signature changed to float arrays)
+    extern "C" void updateVertices_simd(float* updatedVertices_array, float* updatedNormals_array, size_t numVertices, float time);
+
+#else
+
+    // C++ implementation of SIMD version (now also taking float arrays for consistency)
+    void Ocean::updateVertices_simd(float* updatedVertices_array, float* updatedNormals_array, size_t numVertices, float time)
+    {
+        // Placeholder C++ implementation using float arrays
+        //for (size_t i = 0; i < numVertices; ++i) {
+        //    updatedVertices_array[i * 3 + 0] += time * 0.1f; // Example: simple movement in x-direction (modifying float array directly)
+        //}
+        // Update normals in the float array as needed based on your simulation
+    }
+#endif
+
+Ocean::Ocean(int gridSize) : time(0.0f),gridSize(gridSize), gridSpacing(1.0f), 
+                             amplitude(0.8f), wavelength(10.0f), frequency(1.0f), // Adjusted amplitude slightly
+                             direction(glm::vec2(1.0f, 0.0f)), phase(0.0f)
+{
+    gerstnerWaves.push_back({1.0f, 10.0f, 1.0f, glm::normalize(glm::vec2(1.0f, 0.0f)), 0.0f});
+    gerstnerWaves.push_back({0.3f, 5.0f, 2.0f, glm::normalize(glm::vec2(1.0f, 1.0f)), 0.0f});
+    //gerstnerWaves.push_back({1.0f, 3.0f, 1.0f, glm::normalize(glm::vec2(1.0f, 0.5f)), 0.0f});
+    //gerstnerWaves.push_back({0.3f, 5.0f, 2.0f, glm::normalize(glm::vec2(0.5f, 0.5f)), 0.0f});
+    //gerstnerWaves.push_back({1.0f, 10.0f, 1.0f, glm::normalize(glm::vec2(1.0f, 0.0f)), 0.0f});
+    //gerstnerWaves.push_back({0.5f, 2.0f, 3.0f, glm::normalize(glm::vec2(1.0f, 1.0f)), 0.0f});
+    //gerstnerWaves.push_back({1.0f, 1.0f, 0.2f, glm::normalize(glm::vec2(0.7f, 0.2f)), 0.0f});
+    //gerstnerWaves.push_back({0.5f, 1.2f, 2.0f, glm::normalize(glm::vec2(0.9f, 0.8f)), 0.0f});
+}
+
+Ocean::~Ocean()
+{
+    cleanup(); // Call cleanup to release OpenGL resources
+}
+
+bool Ocean::init()
+{
+    generateGrid();
+    createBuffers(); // Create VBOs and IBO
+
+    return true;
+}
+
+void Ocean::cleanup()
+{
+    // No dynamic memory allocation in this simple version
+    // Release OpenGL resources (VBOs, IBO, VAO)
+    glDeleteBuffers(1, &vertexBufferID);
+    glDeleteBuffers(1, &normalBufferID);
+    glDeleteBuffers(1, &texCoordBufferID);
+    glDeleteBuffers(1, &indexBufferID);
+    glDeleteVertexArrays(1, &vaoID);
+    vertexBufferID = 0;
+    normalBufferID = 0;
+    texCoordBufferID = 0;
+    indexBufferID = 0;
+    vaoID = 0;
+}
+
+void add_sse(float* a, float* b, float* result) {
+    __m128 vec1 = _mm_loadu_ps(a);   // Load 4 floats from a
+    __m128 vec2 = _mm_loadu_ps(b);   // Load 4 floats from b
+    __m128 sum = _mm_add_ps(vec1, vec2); // Perform vector addition
+    _mm_storeu_ps(result, sum);      // Store result
+}
+
+
+void Ocean::update(float deltaTime)
+{
+    time += deltaTime;
+    std::vector<glm::vec3> updatedVertices_vec = vertices; // Create a copy to update (vector version)
+    std::vector<glm::vec3> updatedNormals_vec(vertices.size()); // Vector to store updated normals (vector version)
+
+    std::vector<glm::vec3> updatedVertices_simd_vec = vertices; // Create a copy to update (vector for comparison)
+    std::vector<glm::vec3> updatedNormals_simd_vec(vertices.size()); // Vector to store updated normals (vector for comparison)
+
+
+    // --- Conversion to Float Arrays for SIMD function ---
+    size_t numVertices = vertices.size();
+    size_t floatArraySize = numVertices * 3;
+
+    float* updatedVertices_array = new float[floatArraySize];
+    float* updatedNormals_array = new float[floatArraySize];
+    float* updatedVertices_simd_array = new float[floatArraySize]; // Array for SIMD function
+    float* updatedNormals_simd_array = new float[floatArraySize]; // Array for SIMD function
+
+
+    // Convert vector of vec3 to float array (for both normal and simd versions)
+    for (size_t i = 0; i < numVertices; ++i) {
+        updatedVertices_array[i * 3 + 0] = updatedVertices_vec[i].x;
+        updatedVertices_array[i * 3 + 1] = updatedVertices_vec[i].y;
+        updatedVertices_array[i * 3 + 2] = updatedVertices_vec[i].z;
+
+        updatedNormals_array[i * 3 + 0] = updatedNormals_vec[i].x; // Normals init - adjust as needed
+        updatedNormals_array[i * 3 + 1] = updatedNormals_vec[i].y;
+        updatedNormals_array[i * 3 + 2] = updatedNormals_vec[i].z;
+
+        updatedVertices_simd_array[i * 3 + 0] = updatedVertices_simd_vec[i].x; // SIMD version init
+        updatedVertices_simd_array[i * 3 + 1] = updatedVertices_simd_vec[i].y;
+        updatedVertices_simd_array[i * 3 + 2] = updatedVertices_simd_vec[i].z;
+
+        updatedNormals_simd_array[i * 3 + 0] = updatedNormals_simd_vec[i].x; // SIMD normals init
+        updatedNormals_simd_array[i * 3 + 1] = updatedNormals_simd_vec[i].y;
+        updatedNormals_simd_array[i * 3 + 2] = updatedNormals_simd_vec[i].z;
+
+    }
+    auto start_time = std::chrono::high_resolution_clock::now();
+    uint64_t start = rdtsc();
+    // --- Call C++ version for comparison (using vector) ---
+    updateVertices(&updatedVertices_vec, &updatedNormals_vec, time);
+
+    uint64_t end = rdtsc();
+
+    auto end_time = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+
+    std::cout << "Ocean::update took " << duration.count() << "ns " <<  "CPU cycles: " << (end - start) << std::endl;
+
+
+    start_time = std::chrono::high_resolution_clock::now();
+    start = rdtsc();
+
+    // --- Call SIMD version (now taking float arrays) ---
+    updateVertices_simd(updatedVertices_simd_array, updatedNormals_simd_array, numVertices, time);
+    end = rdtsc();
+
+    end_time = std::chrono::high_resolution_clock::now();
+    duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+
+    std::cout << "Ocean::update (SIMD) took " << duration.count() << "ns " <<  "CPU cycles: " << (end - start) << std::endl;
+
+
+    // --- Convert float arrays back to vectors for updateBuffers (if needed) ---
+    std::vector<glm::vec3> updatedVertices_vec_from_array(numVertices);
+    std::vector<glm::vec3> updatedNormals_vec_from_array(numVertices);
+
+    for (size_t i = 0; i < numVertices; ++i) {
+        updatedVertices_vec_from_array[i].x = updatedVertices_simd_array[i * 3 + 0];
+        updatedVertices_vec_from_array[i].y = updatedVertices_simd_array[i * 3 + 1];
+        updatedVertices_vec_from_array[i].z = updatedVertices_simd_array[i * 3 + 2];
+
+        updatedNormals_vec_from_array[i].x = updatedNormals_simd_array[i * 3 + 0];
+        updatedNormals_vec_from_array[i].y = updatedNormals_simd_array[i * 3 + 1];
+        updatedNormals_vec_from_array[i].z = updatedNormals_simd_array[i * 3 + 2];
+    }
+
+
+    updateBuffers(updatedVertices_vec_from_array, updatedNormals_vec_from_array); // Use vectors for updateBuffers
+
+
+    // --- Deallocate float arrays ---
+
+}
+
+
+
+void Ocean::generateGrid()
+{
+    //std::cout << "Ocean::generateGrid - gridSize: " << gridSize << " " << vertices.size()<< std::endl;
+    vertices.resize(gridSize * gridSize);
+    // Resize original coordinate vectors
+    originalWorldX.resize(gridSize * gridSize);
+    originalWorldZ.resize(gridSize * gridSize);
+
+    for (int x = 0; x < gridSize; ++x) {
+        for (int z = 0; z < gridSize; ++z) {
+            float worldX = (x - gridSize / 2.0f) * gridSpacing;
+            float worldZ = (z - gridSize / 2.0f) * gridSpacing;
+            vertices[x * gridSize + z] = glm::vec3(worldX, 0.0f, worldZ);
+
+            // Store original world coordinates
+            originalWorldX[x * gridSize + z] = worldX;
+            originalWorldZ[x * gridSize + z] = worldZ;
+        }
+    }
+}
+
+void Ocean::createBuffers()
+{
+    glGenVertexArrays(1, &vaoID);
+    checkGLError("glGenVertexArrays"); // Check after glGenVertexArrays
+    glBindVertexArray(vaoID);
+    checkGLError("glBindVertexArray"); // Check after glBindVertexArray
+
+    // Generate VBOs
+    glGenBuffers(1, &vertexBufferID);
+    checkGLError("glGenBuffers - vertexBufferID"); // Check after glGenBuffers
+    glGenBuffers(1, &normalBufferID);
+    checkGLError("glGenBuffers - normalBufferID"); // Check after glGenBuffers
+    glGenBuffers(1, &texCoordBufferID);
+    checkGLError("glGenBuffers - texCoordBufferID"); // Check after glGenBuffers
+    glGenBuffers(1, &indexBufferID);
+    checkGLError("glGenBuffers - indexBufferID"); // Check after glGenBuffers
+
+    // 1. Vertex Positions VBO
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
+    checkGLError("glBindBuffer - vertexBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_DYNAMIC_DRAW);
+    checkGLError("glBufferData - vertexBufferID"); // Check after glBufferData
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
+    checkGLError("glVertexAttribPointer - vertexBufferID"); // Check after glVertexAttribPointer
+    glEnableVertexAttribArray(0);
+    checkGLError("glEnableVertexAttribArray - location 0"); // Check after glEnableVertexAttribArray
+
+    // 2. Vertex Normals VBO (initially flat normals - updated in updateVertices/updateBuffers)
+    std::vector<glm::vec3> normals(vertices.size(), glm::vec3(0.0f, 1.0f, 0.0f)); // Initialize with flat normals
+    glBindBuffer(GL_ARRAY_BUFFER, normalBufferID);
+    checkGLError("glBindBuffer - normalBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), normals.data(), GL_DYNAMIC_DRAW);
+    checkGLError("glBufferData - normalBufferID"); // Check after glBufferData
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
+    checkGLError("glVertexAttribPointer - normalBufferID"); // Check after glVertexAttribPointer
+    glEnableVertexAttribArray(1);
+    checkGLError("glEnableVertexAttribArray - location 1"); // Check after glEnableVertexAttribArray
+
+    // 3. Texture Coordinates VBO
+    std::vector<glm::vec2> texCoords(vertices.size());
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            float texU = static_cast<float>(x) / 70.0f;
+            float texV = static_cast<float>(z) / 70.0f;
+            texCoords[x * gridSize + z] = glm::vec2(texU, texV);
+        }
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, texCoordBufferID);
+    checkGLError("glBindBuffer - texCoordBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ARRAY_BUFFER, texCoords.size() * sizeof(glm::vec2), texCoords.data(), GL_STATIC_DRAW);
+    checkGLError("glBufferData - texCoordBufferID"); // Check after glBufferData
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0);
+    checkGLError("glVertexAttribPointer - texCoordBufferID"); // Check after glVertexAttribPointer
+    glEnableVertexAttribArray(2);
+    checkGLError("glEnableVertexAttribArray - location 2"); // Check after glEnableVertexAttribArray
+
+    // 4. Index Buffer Object (IBO) for Quads
+    std::vector<unsigned int> indices;
+    for (int x = 0; x < gridSize - 1; ++x)
+    {
+        for (int z = 0; z < gridSize - 1; ++z)
+        {
+            unsigned int v00 = x * gridSize + z;
+            unsigned int v10 = (x + 1) * gridSize + z;
+            unsigned int v11 = (x + 1) * gridSize + (z + 1);
+            unsigned int v01 = x * gridSize + (z + 1);
+            indices.insert(indices.end(), {v00, v10, v11, v01}); // Quad indices (counter-clockwise)
+        }
+    }
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
+    checkGLError("glBindBuffer - indexBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW);
+    checkGLError("glBufferData - indexBufferID"); // Check after glBufferData
+
+    glBindVertexArray(0);                                   // Unbind VAO
+    checkGLError("glBindVertexArray(0)");                   // Check after unbinding VAO
+    glBindBuffer(GL_ARRAY_BUFFER, 0);                       // Unbind VBO - Optional, VAO unbinding often unbinds VBOs
+    checkGLError("glBindBuffer(0) - ARRAY_BUFFER");         // Check after unbinding ARRAY_BUFFER
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);               // Unbind IBO - Optional, VAO unbinding often unbinds IBO
+    checkGLError("glBindBuffer(0) - ELEMENT_ARRAY_BUFFER"); // Check after unbinding ELEMENT_ARRAY_BUFFER
+    indexCount = indices.size();                            // Store index count for rendering
+}
+
+void Ocean::updateVertices(std::vector<glm::vec3> * updatedVertices, std::vector<glm::vec3> * updatedNormals, float time)
+{
+
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+
+            glm::vec3 &vertex = vertices[x * gridSize + z];
+            float originalX = originalWorldX[x * gridSize + z];
+            float originalZ = originalWorldZ[x * gridSize + z];
+            vertex.y = getWaveHeight(vertex.x, vertex.z, time);
+
+            (*updatedNormals)[x * gridSize + z] = getWaveNormal(originalX, originalZ, time); // Calculate normal using original coords
+        }
+    }
+    //vertices = updatedVertices; // Assign the updated vertices back
+    //updateBuffers(updatedVertices, updatedNormals);
+}
+
+void Ocean::updateBuffers(const std::vector<glm::vec3> &updatedVertices, const std::vector<glm::vec3> &updatedNormals)
+{
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, updatedVertices.size() * sizeof(glm::vec3), updatedVertices.data()); // Update vertex positions
+
+    glBindBuffer(GL_ARRAY_BUFFER, normalBufferID);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, updatedNormals.size() * sizeof(glm::vec3), updatedNormals.data()); // Update normals
+}
+
+glm::vec3 Ocean::getVertex(int x, int z) const
+{
+    return vertices[x * gridSize + z];
+}
+
+float Ocean::getWaveHeight(float x, float z, float time) const {
+    float totalHeight = 0.0f;
+    for (const auto& wave : gerstnerWaves) {
+        totalHeight += getGerstnerWaveHeight(wave, x, z, time);
+    }
+    return totalHeight;
+}
+
+float Ocean::getGerstnerWaveHeight(const GerstnerWave& wave, float x, float z, float time) const {
+    float k = 2.0f * glm::pi<float>() / wave.wavelength;
+    float w = wave.speed * k;
+    float dotProduct = glm::dot(wave.direction, glm::vec2(x, z));
+    float periodicAmplitude = wave.amplitude * 0.5f * (1.0f + sin(2.0f * glm::pi<float>() * time / wave.wavelength));
+    float waveHeightValue = periodicAmplitude * sin(k * dotProduct - w * time + wave.phase);
+
+    if (fabs(x) < 0.5f && fabs(z) < 0.5f) {
+        //std::cout << "  getGerstnerWaveHeight - time: " << time << ", periodicAmplitude: " << periodicAmplitude << ", waveHeightValue: " << waveHeightValue << std::endl;
+    }
+
+    return waveHeightValue;
+}
+
+glm::vec3 Ocean::getGerstnerWaveDisplacement(const GerstnerWave& wave, float x, float z, float time) const {
+    float k = 2.0f * glm::pi<float>() / wave.wavelength;
+    float w = wave.speed * k;
+    float dotProduct = glm::dot(wave.direction, glm::vec2(x, z));
+    float cosTerm = cos(k * dotProduct - w * time + wave.phase);
+    float periodicAmplitude = wave.amplitude * 0.5f * (1.0f + sin(2.0f * glm::pi<float>() * time / wave.wavelength));
+    return glm::vec3(wave.direction.x * periodicAmplitude * cosTerm,
+                     0.0f,
+                     wave.direction.y * periodicAmplitude * cosTerm);
+}
+
+glm::vec3 Ocean::getWaveNormal(float x, float z, float time) const {
+    glm::vec3 tangentX = glm::vec3(1.0f, 0.0f, 0.0f);
+    glm::vec3 tangentZ = glm::vec3(0.0f, 0.0f, 1.0f);
+
+    for (const auto& wave : gerstnerWaves) {
+        float k = 2.0f * glm::pi<float>() / wave.wavelength;
+        float w = wave.speed * k;
+        float dotProduct = glm::dot(wave.direction, glm::vec2(x, z));
+        float sinTerm = sin(k * dotProduct - w * time + wave.phase);
+        float cosTerm = cos(k * dotProduct - w * time + wave.phase);
+        float periodicAmplitude = wave.amplitude * 0.5f * (1.0f + sin(2.0f * glm::pi<float>() * time /  wave.wavelength));
+        float modulatedAmplitude = periodicAmplitude;
+
+        // Calculate tangent vectors for EACH wave component and ACCUMULATE them directly
+        tangentX += glm::vec3(
+            -modulatedAmplitude * wave.direction.x * wave.direction.x * k * sinTerm, // dx_dx
+             modulatedAmplitude * wave.direction.x * k * cosTerm,                 // dy_dx
+            -modulatedAmplitude * wave.direction.x * wave.direction.y * k * sinTerm  // dz_dx
+        );
+
+        tangentZ += glm::vec3(
+            -modulatedAmplitude * wave.direction.x * wave.direction.y * k * sinTerm, // dx_dz
+             modulatedAmplitude * wave.direction.y * k * cosTerm,                 // dy_dz
+            -modulatedAmplitude * wave.direction.y * wave.direction.y * k * sinTerm  // dz_dz
+        );
+    }
+
+    return glm::normalize(glm::cross(tangentZ, tangentX));
+}
+void Ocean::setGridSize(int newGridSize)
+{
+    gridSize = newGridSize;
+    generateGrid();   // Re-generate the grid with the new size
+
+    std::vector<glm::vec3> updatedVertices = vertices; // Create a copy to update
+    std::vector<glm::vec3> updatedNormals(vertices.size()); // Vector to store updated normals
+
+    updateVertices(&updatedVertices, &updatedNormals, time);
+
+    updateBuffers(updatedVertices, updatedNormals); 
+    //updateVertices(); // Re-update vertices based on waves (optional, if needed immediately)
+}
+
+GLuint Ocean::getVAO() const
+{
+    return vaoID;
+}
+
+GLuint Ocean::getIndexCount() const
+{
+    return indexCount;
+}
+
+int Ocean::getGridIndex(int x, int z) const {
+    return x * gridSize + z;
+}

linux/src/Shader.cpp

@@ -0,0 +1,126 @@
+/*
+ * File:        Shader.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Shader controll
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Shader.h"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+
+Shader::Shader() : vertexShaderID(0), fragmentShaderID(0), programID(0) {}
+
+Shader::~Shader() {
+    cleanup();
+}
+
+
+bool Shader::loadShader(const char* vertexShaderPath, const char* fragmentShaderPath) {
+    // 1. Compile vertex and fragment shaders
+    if (!compileShader(vertexShaderID, GL_VERTEX_SHADER, vertexShaderPath)) return false;
+    if (!compileShader(fragmentShaderID, GL_FRAGMENT_SHADER, fragmentShaderPath)) return false;
+
+    // 2. Link shader program
+    if (!linkShaderProgram()) return false;
+
+    return true; // Shader program loaded and linked successfully
+}
+
+
+bool Shader::compileShader(GLuint& shaderID, GLenum shaderType, const char* shaderPath) {
+    shaderID = glCreateShader(shaderType);
+    std::string shaderCode;
+    std::ifstream shaderFile;
+    shaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit); // Enable exception throwing
+    try {
+        shaderFile.open(shaderPath);
+        std::stringstream shaderStream;
+        shaderStream << shaderFile.rdbuf();
+        shaderFile.close();
+        shaderCode = shaderStream.str();
+    } catch (std::ifstream::failure& e) {
+        std::cerr << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ: " << shaderPath << std::endl;
+        return false;
+    }
+    const char* shaderCodeCStr = shaderCode.c_str();
+    glShaderSource(shaderID, 1, &shaderCodeCStr, NULL);
+    glCompileShader(shaderID);
+
+    // Check for shader compile errors
+    int success;
+    char infoLog[512];
+    glGetShaderiv(shaderID, GL_COMPILE_STATUS, &success);
+    if (!success) {
+        glGetShaderInfoLog(shaderID, 512, NULL, infoLog);
+        std::cerr << "ERROR::SHADER::COMPILATION_FAILED: " << shaderPath << "\n" << infoLog << std::endl;
+        return false;
+    }
+    return true;
+}
+
+
+bool Shader::linkShaderProgram() {
+    programID = glCreateProgram();
+    glAttachShader(programID, vertexShaderID);
+    glAttachShader(programID, fragmentShaderID);
+    glLinkProgram(programID);
+
+    // Check for linking errors
+    int success;
+    char infoLog[512];
+    glGetProgramiv(programID, GL_LINK_STATUS, &success);
+    if (!success) {
+        glGetProgramInfoLog(programID, 512, NULL, infoLog);
+        std::cerr << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
+        return false;
+    }
+
+    glDeleteShader(vertexShaderID);   // Delete shaders as they are linked into program now and no longer necessary
+    glDeleteShader(fragmentShaderID); // Shader objects are deleted after linking
+    vertexShaderID = 0;
+    fragmentShaderID = 0;
+
+    return true;
+}
+
+
+void Shader::use() {
+    glUseProgram(programID);
+}
+
+void Shader::unuse() {
+    glUseProgram(0); // Unuse shader program (use fixed-function pipeline)
+}
+
+void Shader::cleanup() {
+    if (programID != 0) {
+        glDeleteProgram(programID);
+        programID = 0;
+    }
+}
+
+
+void Shader::setInt(const std::string& name, int value) const {
+    glUniform1i(glGetUniformLocation(programID, name.c_str()), value);
+}
+
+void Shader::setFloat(const std::string& name, float value) const {
+    glUniform1f(glGetUniformLocation(programID, name.c_str()), value);
+}
+
+void Shader::setVec3(const std::string& name, const glm::vec3& value) const {
+    glUniform3fv(glGetUniformLocation(programID, name.c_str()), 1, glm::value_ptr(value));
+}
+
+void Shader::setMat4(const std::string& name, const glm::mat4& mat) const {
+    glUniformMatrix4fv(glGetUniformLocation(programID, name.c_str()), 1, GL_FALSE, glm::value_ptr(mat));
+}
+void Shader::setMat3(const std::string& name, const glm::mat3& mat) const {
+     glUniformMatrix3fv(glGetUniformLocation(programID, name.c_str()), 1, GL_FALSE, glm::value_ptr(mat));
+}

linux/src/Terrain.cpp

@@ -0,0 +1,195 @@
+/*
+ * File:        Terran.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class defines terrain (surface).
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "Terrain.h"
+#include <cmath>
+#include <glm/gtc/constants.hpp>
+#include <iostream>
+#include "utils.h" // Include utils.h for checkGLError
+#include <GL/glew.h>
+
+Terrain::Terrain(int gridSize, float gridSpacing)
+    : gridSize(gridSize),
+      gridSpacing(gridSpacing),
+      vertices(gridSize * gridSize),
+      normals(gridSize * gridSize),
+      texCoords(gridSize * gridSize),
+      vertexBufferID(0),
+      normalBufferID(0),
+      texCoordBufferID(0),
+      indexBufferID(0),
+      vaoID(0),
+      indexCount(0) {}
+
+Terrain::~Terrain() {
+    cleanup();
+}
+
+bool Terrain::init(GLuint heightMapTextureID) {
+    generateGrid(heightMapTextureID);
+    createBuffers();
+    return true;
+}
+
+void Terrain::cleanup() {
+    glDeleteBuffers(1, &vertexBufferID);
+    glDeleteBuffers(1, &normalBufferID);
+    glDeleteBuffers(1, &texCoordBufferID);
+    glDeleteBuffers(1, &indexBufferID);
+    glDeleteVertexArrays(1, &vaoID);
+}
+
+
+
+void Terrain::generateGrid(GLuint heightMapTextureID) {
+
+    std::cout << "Terrain::generateGrid - gridSize: " << gridSize << std::endl;
+    vertices.resize(gridSize * gridSize);
+    normals.resize(gridSize * gridSize);
+    texCoords.resize(gridSize * gridSize);
+
+    // **Access Heightmap Texture Data**
+    glBindTexture(GL_TEXTURE_2D, heightMapTextureID); // Bind heightmap texture
+    GLint textureWidth, textureHeight;
+    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &textureWidth); // Get texture width
+    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &textureHeight); // Get texture height
+
+    std::vector<unsigned char> heightmapData(textureWidth * textureHeight); // Assuming 8-bit grayscale heightmap
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RED, GL_UNSIGNED_BYTE, heightmapData.data()); // Get texture pixel data (Red channel = grayscale height)
+    glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture
+
+    float heightScale = 40.0f; // Adjust this to control terrain height scale
+
+    for (int x = 0; x < gridSize; ++x) {
+        for (int z = 0; z < gridSize; ++z) {
+            float worldX = (x - gridSize / 2.0f) * gridSpacing;
+            float worldZ = (z - gridSize / 2.0f) * gridSpacing;
+
+            // **Sample height from heightmap texture**
+            float height = 0.0f;
+            if (x < textureWidth && z < textureHeight && x >= 0 && z >= 0) { // Bounds check - important!
+                height = static_cast<float>(heightmapData[z * textureWidth + x]) / 255.0f * heightScale-15.0; // Normalize to [0, 1], scale by heightScale
+
+            } else {
+                // Handle out-of-bounds access (e.g., set height to 0 or a default value)
+                height = 0.0f;
+            }
+
+            //vertices[x * gridSize + z] = glm::vec3(worldX, height, worldZ); // Set vertex position with height from heightmap
+            vertices[x * gridSize + z] = glm::vec3(worldX, height, worldZ); // Flat terrain at y=0
+            normals[x * gridSize + z] = glm::vec3(0.0f, 1.0f, 0.0f);    // Upward normals for flat terrain
+            texCoords[x * gridSize + z] = glm::vec2(static_cast<float>(x) / 50.0f, static_cast<float>(z) / 50.0f); // Example texture tiling
+            //originalWorldX[x * gridSize + z] = worldX;
+            //originalWorldZ[x * gridSize + z] = worldZ;
+        }
+    }
+    std::cout << "Width: " << textureWidth << "Geight: " << textureHeight << std::endl;
+}
+
+
+void Terrain::createBuffers() {
+    glGenVertexArrays(1, &vaoID);
+    checkGLError("1"); // Check after drawMeshVBO call
+
+    glBindVertexArray(vaoID);
+    checkGLError("2"); // Check after drawMeshVBO call
+
+    glGenBuffers(1, &vertexBufferID);
+    checkGLError("3"); // Check after drawMeshVBO call
+
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
+    checkGLError("4"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW);
+    checkGLError("5"); // Check after drawMeshVBO call
+
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
+    checkGLError("6"); // Check after drawMeshVBO call
+
+    glEnableVertexAttribArray(0);
+    checkGLError("7"); // Check after drawMeshVBO call
+
+    glGenBuffers(1, &normalBufferID);
+    checkGLError("8"); // Check after drawMeshVBO call
+
+    glBindBuffer(GL_ARRAY_BUFFER, normalBufferID);
+    checkGLError("9"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), normals.data(), GL_STATIC_DRAW);
+    checkGLError("10"); // Check after drawMeshVBO call
+
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
+    checkGLError("11"); // Check after drawMeshVBO call
+
+    glEnableVertexAttribArray(1);
+    checkGLError("12"); // Check after drawMeshVBO call
+
+
+    glGenBuffers(1, &texCoordBufferID);
+    checkGLError("13"); // Check after drawMeshVBO call
+
+    glBindBuffer(GL_ARRAY_BUFFER, texCoordBufferID);
+    checkGLError("14"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ARRAY_BUFFER, texCoords.size() * sizeof(glm::vec2), texCoords.data(), GL_STATIC_DRAW);
+    checkGLError("15"); // Check after drawMeshVBO call
+
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);
+    checkGLError("16"); // Check after drawMeshVBO call
+
+    glEnableVertexAttribArray(2);
+    checkGLError("17"); // Check after drawMeshVBO call
+
+
+    std::vector<unsigned int> indices;
+    for (int x = 0; x < gridSize - 1; ++x) {
+        for (int z = 0; z < gridSize - 1; ++z) {
+            unsigned int v00 = x * gridSize + z;
+            unsigned int v10 = (x + 1) * gridSize + z;
+            unsigned int v11 = (x + 1) * gridSize + (z + 1);
+            unsigned int v01 = x * gridSize + (z + 1);
+            indices.insert(indices.end(), {v00, v10, v11, v01});
+        }
+    }
+    glGenBuffers(1, &indexBufferID);
+    checkGLError("glGenBuffers - indexBufferID"); // Check after glGenBuffers
+    
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
+    checkGLError("18"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW);
+    checkGLError("19"); // Check after drawMeshVBO call
+
+    glBindVertexArray(0);
+    checkGLError("20"); // Check after drawMeshVBO call
+
+    indexCount = indices.size();
+}
+
+void Terrain::updateBuffers() {
+    // Not needed for static terrain in this basic example
+}
+
+
+glm::vec3 Terrain::getVertex(int x, int z) const {
+    assert(x >= 0 && x < gridSize);
+    assert(z >= 0 && z < gridSize);
+    return vertices[x * gridSize + z];
+}
+
+
+glm::vec3 Terrain::getNormal(float x, float z) const
+{
+    return normals[x * gridSize + z];
+
+}

linux/src/main.cpp

@@ -0,0 +1,21 @@
+/*
+ * File:        main.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Main
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Game.h"
+
+int main(int argc, char** argv) {
+    Game game;
+    if (!game.init(argc, argv)) {
+        return 1;
+    }
+    game.run();
+    game.cleanup();
+    return 0;
+}

linux/src/render.cpp

@@ -0,0 +1,634 @@
+/*
+ * File:        render.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Game renderer
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+
+#include "Renderer.h"
+#include <iostream>
+#include <SOIL/SOIL.h>
+#include "utils.h"
+#include <glm/gtc/type_ptr.hpp>
+
+
+
+
+Renderer::Renderer() : oceanTextureID(0), boatTextureID(0), terrainTextureID(0), heightMapTextureID(0) {}
+
+Renderer::~Renderer() {}
+
+bool Renderer::init()
+{
+    glewInit();
+    if (glewIsSupported("GL_VERSION_3_0"))
+    {
+        std::cout << "OpenGL 3.0 or higher supported: Shaders will work." << std::endl;
+    }
+    else
+    {
+        std::cout << "OpenGL 3.0 or higher NOT supported: Shaders might not work." << std::endl;
+    }
+
+    glClearColor(0.529f, 0.808f, 0.922f, 1.0f); // Light blue background
+
+    if (!loadTexture("assets/textures/ocean_texture.png", oceanTextureID))
+    {
+        std::cerr << "Error loading ocean texture." << std::endl;
+        return false;
+    }
+    if (!loadTexture("assets/textures/rock_texture.png", terrainTextureID)) { // Assuming you name it terrain_texture.jpg
+        std::cerr << "Error loading terrain texture." << std::endl;
+        return false;
+    }
+    checkGLError("loadTexture - terrainTexture"); // Check after terrain texture loading
+
+    // **Load heightmap texture:**
+    if (!loadTexture("assets/textures/terain.png", heightMapTextureID)) { // Assuming heightmap is terrain_heightmap.png
+        std::cerr << "Error loading terrain heightmap texture." << std::endl;
+        return false;
+    }
+    checkGLError("loadTexture - heightMapTexture"); // Check after heightmap texture loading
+
+    terrainShader.loadShader("assets/shaders/terrain_vertex_shader.glsl", "assets/shaders/terrain_fragment_shader.glsl");
+    if (!terrainShader.isLoaded()) {
+        std::cerr << "Error loading terrain shader program!" << std::endl;
+        return false;
+    }
+    checkGLError("terrainShader.loadShader"); // Check after shader loading
+    // Load and compile ocean shader program:
+    oceanShader.loadShader("assets/shaders/ocean_vertex_shader.glsl", "assets/shaders/ocean_fragment_shader.glsl");
+    if (!oceanShader.isLoaded()) {
+        std::cerr << "Error loading ocean shader program!" << std::endl;
+        return false;
+    }
+    checkGLError("oceanShader.loadShader"); // Check after shader loading
+    // Boat texture is now loaded in drawBoat, based on Boat class texture path
+
+    setupLighting();
+    // shaderProgram.loadShader("assets/shaders/vertex_shader.glsl", "assets/shaders/fragment_shader.glsl"); // Optional shader loading
+
+    return true;
+}
+
+void Renderer::cleanup()
+{
+    glDeleteTextures(1, &oceanTextureID);
+    glDeleteTextures(1, &boatTextureID);
+    glDeleteTextures(1, &terrainTextureID);
+    glDeleteTextures(1, &heightMapTextureID);
+
+    // shaderProgram.cleanup(); // Optional shader cleanup
+}
+
+void Renderer::renderScene(const Ocean &ocean, const Boat &boat, const Camera &camera, const Terrain &terrain)
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glLoadIdentity();
+
+    camera.lookAt(); // Set up camera view
+
+    setupLighting(); // Ensure lighting is enabled each frame
+    drawTerrain(terrain, camera); // **Call drawTerrain here - BEFORE drawOcean**
+
+    drawOcean(ocean, camera);
+    drawBoat(boat);
+    checkGLError("drawTerrain"); // Check after drawTerrain
+    // Optional: Render skybox, UI, etc.
+    // ...
+}
+
+void Renderer::reshape(int width, int height)
+{
+    glViewport(0, 0, width, height);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(45.0f, static_cast<float>(width) / height, 0.1f, 100.0f); // Adjust near/far planes
+    glMatrixMode(GL_MODELVIEW);
+}
+
+bool Renderer::loadTexture(const char *filename, GLuint &textureID)
+{
+    textureID = SOIL_load_OGL_texture(filename, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_INVERT_Y);
+    if (textureID == 0)
+    {
+        std::cerr << "SOIL loading error: '" << SOIL_last_result() << "' (" << filename << ")" << std::endl;
+        return false;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, textureID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps for better quality at distance
+    glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture
+    return true;
+}
+
+void Renderer::setupLighting()
+{
+    glEnable(GL_LIGHTING);
+    glEnable(GL_LIGHT0);
+
+    GLfloat lightAmbient[] = {0.2f, 0.2f, 0.2f, 1.0f};
+    GLfloat lightDiffuse[] = {0.8f, 0.8f, 0.8f, 1.0f};
+    GLfloat lightSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f};
+    GLfloat lightPosition[] = {10.0f, 10.0f, 10.0f, 0.0f}; // Directional light from above and to the right
+
+    glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse);
+    glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular);
+    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
+
+    glEnable(GL_COLOR_MATERIAL);
+    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); // Material colors track glColor
+    GLfloat matSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f};
+    GLfloat matShininess[] = {50.0f};
+    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular);
+    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, matShininess);
+}
+
+void Renderer::drawOcean(const Ocean& ocean, const Camera& camera)
+{
+    
+    glPushMatrix();
+
+    // Use the ocean shader program:
+    oceanShader.use();
+    checkGLError("oceanShader.use"); // Check after shader use
+
+    // Set Uniforms for Ocean Shader:
+    glm::mat4 modelMatrix;
+    glm::mat4 projectionMatrix;
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(modelMatrix));
+    checkGLError("glGetFloatv(GL_MODELVIEW_MATRIX)"); // Check after glGetFloatv
+    glGetFloatv(GL_PROJECTION_MATRIX, glm::value_ptr(projectionMatrix));
+    checkGLError("glGetFloatv(GL_PROJECTION_MATRIX)"); // Check after glGetFloatv
+
+
+    oceanShader.setMat4("model", modelMatrix);
+    oceanShader.setMat4("view", camera.getViewMatrix());
+    oceanShader.setMat4("projection", projectionMatrix);
+    oceanShader.setMat3("normalMatrix", glm::transpose(glm::inverse(glm::mat3(modelMatrix))));
+    checkGLError("shader.setMat4/setMat3 uniforms"); // Check after setting matrix uniforms
+
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, oceanTextureID);
+    oceanShader.setInt("oceanTexture", 0);
+    checkGLError("glBindTexture - oceanTexture"); // Check after glBindTexture
+
+    //glActiveTexture(GL_TEXTURE1);
+    //glBindTexture(GL_TEXTURE_2D, normalMapTextureID);
+    //oceanShader.setInt("normalMap", 1);
+    //checkGLError("glBindTexture - normalMapTexture"); // Check after glBindTexture
+
+
+    oceanShader.setVec3("lightDir", glm::normalize(glm::vec3(1.0f, 1.0f, 1.0f)));
+    oceanShader.setVec3("lightColor", glm::vec3(1.0f, 1.0f, 1.0f));
+    oceanShader.setVec3("viewPosWorld", camera.getPosition());
+    checkGLError("shader.setVec3 uniforms"); // Check after setting vec3 uniforms
+
+
+    drawMeshVBO(ocean); // Draw using VBOs and IBO
+    checkGLError("drawMeshVBO"); // Check after drawMeshVBO call
+
+    // Unuse shader program after drawing ocean
+    oceanShader.unuse();
+    checkGLError("oceanShader.unuse"); // Check after shader unuse
+
+    //glPopMatrix();
+
+    glPushMatrix();
+    //glTranslatef(0.0f, -1.0f, 0.0f); // Lower the ocean slightly
+
+    // **Disable Texture and Lighting for Normal Visualization**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(1.0f, 0.0f, 0.0f); // Red color for normals (you can change this)
+
+    int gridSize = ocean.getGridSize();
+    float gridSpacing = ocean.getGridSpacing();
+
+    #if SHOW_NORM
+    
+
+    // **Draw Normals as Lines**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = ocean.getVertex(x, z);
+            glm::vec3 normal = ocean.getWaveNormal(v.x, v.z, ocean.time); // Get normal at vertex
+
+            // Calculate endpoint of normal line - Scale normal for visibility
+            float normalLength = 0.5f; // Adjust this value to control normal line length
+            glm::vec3 normalEndpoint = v + normal * normalLength;
+
+            // Draw line representing the normal
+            glVertex3f(v.x, v.y, v.z);                                        // Start point of normal line (vertex position)
+            glVertex3f(normalEndpoint.x, normalEndpoint.y, normalEndpoint.z); // End point of normal line (along normal direction)
+        }
+    }
+    glEnd();
+
+    #endif
+
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+
+    glPopMatrix();
+
+    glPushMatrix();
+
+    // **Disable Texture and Lighting for Wireframe Rendering**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(0.0f, 0.0f, 0.0f); // Green color for wireframe (you can change this)
+
+
+
+
+    #if SHOW_GRID
+
+    // **Change glBegin mode to GL_LINES for Wireframe**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = ocean.getVertex(x, z);
+
+            // Draw horizontal lines (along Z-axis)
+            if (x < gridSize - 1)
+            {
+                glm::vec3 v_next_x = ocean.getVertex(x + 1, z);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_x.x, v_next_x.y, v_next_x.z);
+            }
+            // Draw vertical lines (along X-axis)
+            if (z < gridSize - 1)
+            {
+                glm::vec3 v_next_z = ocean.getVertex(x, z + 1);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_z.x, v_next_z.y, v_next_z.z);
+            }
+        }
+    }
+    glEnd();
+
+    #endif
+
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+    glPopMatrix();
+
+    glPopMatrix();
+}
+
+// ... (rest of Renderer.cpp - Renderer::drawBoat, Renderer::drawMesh, etc.) ...
+
+void Renderer::drawBoat(const Boat &boat)
+{
+    glPushMatrix();
+    glm::vec3 boatPos = boat.getPosition();
+    glm::quat boatRotation = boat.getRotation();
+    float boatScale = boat.getScale(); // Get the boat's scale factor
+
+    glTranslatef(boatPos.x, boatPos.y, boatPos.z);
+    glm::mat4 rotationMatrix = glm::mat4_cast(boatRotation);
+    glMultMatrixf(glm::value_ptr(rotationMatrix));
+
+    glScalef(boatScale, boatScale, boatScale); // Uniform scaling - scale equally in all directions
+
+    // Load boat texture here, based on the texture path from the Boat class
+    if (!boat.getTexturePath().empty())
+    {
+        if (boatTextureID == 0 || boat.getTexturePath() != lastBoatTexturePath)
+        { // Check if texture needs to be loaded or reloaded
+            if (boatTextureID != 0)
+            { // If there's a previous texture, delete it
+                glDeleteTextures(1, &boatTextureID);
+                boatTextureID = 0;
+            }
+            if (!loadTexture(boat.getTexturePath().c_str(), boatTextureID))
+            {
+                std::cerr << "Error loading boat texture: " << boat.getTexturePath() << std::endl;
+            }
+            else
+            {
+                lastBoatTexturePath = boat.getTexturePath(); // Store the path of the loaded texture
+            }
+        }
+    }
+
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, boatTextureID);
+    glColor3f(1.0f, 1.0f, 1.0f); // Texture color modulation
+
+    // Draw the loaded boat mesh
+    drawMesh(boat.getVertices(), boat.getNormals(), boat.getTexCoords(), boat.getMaterialIndices(), boat.getMaterials()); // Pass material data
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glDisable(GL_TEXTURE_2D);
+    glPopMatrix();
+
+    glPushMatrix();
+    glm::vec3 minPoint = boat.getBoundingBoxMin(); // Get model-space min point
+    glm::vec3 maxPoint = boat.getBoundingBoxMax(); // Get model-space max point
+
+    glTranslatef(boatPos.x, boatPos.y, boatPos.z);
+    glMultMatrixf(glm::value_ptr(rotationMatrix));
+    glScalef(boatScale, boatScale, boatScale); // Uniform scaling - scale equally in all directions
+                                               // **Draw Wireframe Bounding Box:**
+    glDisable(GL_LIGHTING);                    // Disable lighting for bounding box (solid color wireframe)
+    glColor3f(1.0f, 1.0f, 0.0f);               // Yellow color for bounding box
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Set polygon mode to line (wireframe)
+
+
+    #if SHOW_BOUDING_BOX
+    glBegin(GL_QUADS); // Draw a cube using quads (wireframe)
+
+    // Front face
+    glVertex3f(minPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, maxPoint.z);
+
+    // Back face
+    glVertex3f(minPoint.x, minPoint.y, minPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, minPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, minPoint.z);
+
+    // Top face
+    glVertex3f(minPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, minPoint.z);
+
+    // Bottom face
+    glVertex3f(minPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, minPoint.y, minPoint.z);
+
+    // Right face
+    glVertex3f(maxPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, minPoint.z);
+
+    // Left face
+    glVertex3f(minPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, minPoint.y, minPoint.z);
+
+    glEnd();
+
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Restore polygon mode to fill
+    #endif
+
+    glEnable(GL_LIGHTING);    
+                     // Re-enable lighting for boat model
+    glPopMatrix();
+}
+
+
+void Renderer::drawMeshVBO(const Ocean& ocean) {
+    // 1. Bind Vertex Array Object (VAO) - if you are using VAOs. If not, bind VBOs directly.
+    glBindVertexArray(ocean.getVAO()); // Assuming Ocean class has getVAO() that returns VAO ID
+
+    // If NOT using VAOs, you would bind VBOs individually like this:
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getVertexBufferID()); // Bind vertex VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getNormalBufferID());   // Bind normal VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getTexCoordBufferID()); // Bind texCoord VBO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ocean.getIndexBufferID()); // Bind IBO
+    */
+
+
+    // 2. Draw using glDrawElements (assuming you are using indexed rendering with IBO)
+    glDrawElements(GL_QUADS, ocean.getIndexCount(), GL_UNSIGNED_INT, 0); // Draw using indices from IBO
+
+    // If drawing as triangles instead of quads, use:
+    // glDrawElements(GL_TRIANGLES, ocean.getIndexCount(), GL_UNSIGNED_INT, 0);
+
+
+    // 3. Unbind VAO (or VBOs if not using VAOs) - optional, but good practice
+    glBindVertexArray(0);
+
+    // If NOT using VAOs, unbind VBOs individually (optional):
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    */
+}
+
+void Renderer::drawMeshTerainVBO(const Terrain& terrain) {
+    // 1. Bind Vertex Array Object (VAO) - if you are using VAOs. If not, bind VBOs directly.
+    glBindVertexArray(terrain.getVAO()); // Assuming Ocean class has getVAO() that returns VAO ID
+
+    // If NOT using VAOs, you would bind VBOs individually like this:
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getVertexBufferID()); // Bind vertex VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getNormalBufferID());   // Bind normal VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getTexCoordBufferID()); // Bind texCoord VBO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ocean.getIndexBufferID()); // Bind IBO
+    */
+
+
+    // 2. Draw using glDrawElements (assuming you are using indexed rendering with IBO)
+    glDrawElements(GL_QUADS, terrain.getIndexCount(), GL_UNSIGNED_INT, 0); // Draw using indices from IBO
+
+    // If drawing as triangles instead of quads, use:
+    // glDrawElements(GL_TRIANGLES, ocean.getIndexCount(), GL_UNSIGNED_INT, 0);
+
+
+    // 3. Unbind VAO (or VBOs if not using VAOs) - optional, but good practice
+    glBindVertexArray(0);
+
+    // If NOT using VAOs, unbind VBOs individually (optional):
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    */
+}
+
+// Static variable to store the last loaded boat texture path
+
+void Renderer::drawMesh(const std::vector<glm::vec3> &vertices, const std::vector<glm::vec3> &normals, const std::vector<glm::vec2> &texCoords,
+                        const std::vector<int> &materialIndices, const std::vector<tinyobj::material_t> &materials)
+{
+    glBegin(GL_TRIANGLES);
+    for (size_t i = 0; i < vertices.size(); ++i)
+    {
+        int material_index = materialIndices[i];
+        if (material_index != -1 && static_cast<std::vector<tinyobj::material_t>::size_type>(material_index) < materials.size())
+        { // Check if material index is valid
+            const tinyobj::material_t &material = materials[material_index];
+            glColor3f(material.diffuse[0], material.diffuse[1], material.diffuse[2]); // Set diffuse color
+        }
+        else
+        {
+            glColor3f(1.0f, 1.0f, 1.0f); // Default white color if no valid material
+        }
+
+        glNormal3f(normals[i].x, normals[i].y, normals[i].z);
+        glTexCoord2f(texCoords[i].x, texCoords[i].y);
+        glVertex3f(vertices[i].x, vertices[i].y, vertices[i].z);
+    }
+    glEnd();
+}
+
+// Renderer.cpp - Add drawTerrain function
+void Renderer::drawTerrain(const Terrain& terrain, const Camera& camera) {
+    
+    //printf("Drawing terrain\n");
+    glPushMatrix();
+    // No translation needed for terrain in this basic example
+    glTranslatef(0.0f, 0.0f, 0.0f); // Lower the ocean slightly
+
+    // Use the terrain shader program:
+    terrainShader.use();
+    checkGLError("terrainShader.use");
+
+    glm::mat4 modelMatrix;
+    glm::mat4 projectionMatrix;
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(modelMatrix));
+    checkGLError("glGetFloatv(GL_MODELVIEW_MATRIX)"); // Check after glGetFloatv
+    glGetFloatv(GL_PROJECTION_MATRIX, glm::value_ptr(projectionMatrix));
+    checkGLError("glGetFloatv(GL_PROJECTION_MATRIX)"); // Check after glGetFloatv
+
+    terrainShader.setMat4("model", modelMatrix);
+    terrainShader.setMat4("view", camera.getViewMatrix());
+    terrainShader.setMat4("projection", projectionMatrix);
+    terrainShader.setMat3("normalMatrix", glm::transpose(glm::inverse(glm::mat3(modelMatrix))));
+    checkGLError("terrainShader setMat4/setMat3 uniforms");
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, terrainTextureID);
+    terrainShader.setInt("terrainTexture", 0);
+    checkGLError("glBindTexture - terrainTexture");
+
+    glActiveTexture(GL_TEXTURE1); // Activate texture unit 1 for heightmap
+    glBindTexture(GL_TEXTURE_2D, heightMapTextureID); // Bind heightmap texture
+    terrainShader.setInt("heightMapTexture", 1); // Set uniform sampler2D heightMapTexture to texture unit 1
+    checkGLError("glBindTexture - heightMapTexture"); // Check after binding heightmap texture
+
+    // Lighting Uniforms (reuse same light parameters as ocean for simplicity)
+    terrainShader.setVec3("lightDir", glm::normalize(glm::vec3(1.0f, -1.0f, 1.0f))); // Example light direction
+    terrainShader.setVec3("lightColor", glm::vec3(1.0f, 1.0f, 1.0f)); // White light
+    terrainShader.setVec3("viewPosWorld", camera.getPosition());
+    checkGLError("terrainShader setVec3 uniforms");
+
+
+    drawMeshTerainVBO(terrain); // Render terrain mesh using VBOs and IBO
+    checkGLError("drawMeshVBO - terrain");
+    glBindTexture(GL_TEXTURE_2D, 0); // Bind heightmap texture
+
+    terrainShader.unuse();
+    checkGLError("terrainShader.unuse");
+
+    glPopMatrix();
+
+    
+
+    glPushMatrix();
+    glTranslatef(0.0f, 0.0f, 0.0f); // Lower the ocean slightly
+
+    // **Disable Texture and Lighting for Normal Visualization**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(1.0f, 0.0f, 0.0f); // Red color for normals (you can change this)
+
+
+    #if SHOW_NORM
+
+    int gridSize = terrain.getGridSize();
+    float gridSpacing = terrain.getGridSpacing();
+
+    // **Draw Normals as Lines**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = terrain.getVertex(x, z);
+            glm::vec3 normal = terrain.getNormal(x, z); // Get normal at vertex
+
+            // Calculate endpoint of normal line - Scale normal for visibility
+            float normalLength = 0.5f; // Adjust this value to control normal line length
+            glm::vec3 normalEndpoint = v + normal * normalLength;
+
+            // Draw line representing the normal
+            glVertex3f(v.x, v.y, v.z);                                        // Start point of normal line (vertex position)
+            glVertex3f(normalEndpoint.x, normalEndpoint.y, normalEndpoint.z); // End point of normal line (along normal direction)
+        }
+    }
+    glEnd();
+
+    #endif
+
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+
+    glPopMatrix();
+
+
+
+    glPushMatrix();
+    glTranslatef(0.0f, 0.2f, 0.0f); // Lower the ocean slightly
+
+    // **Disable Texture and Lighting for Wireframe Rendering**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(0.0f, 0.0f, 0.0f); // Green color for wireframe (you can change this)
+
+    #if SHOW_GRID
+    // **Change glBegin mode to GL_LINES for Wireframe**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = terrain.getVertex(x, z);
+
+            // Draw horizontal lines (along Z-axis)
+            if (x < gridSize - 1)
+            {
+                glm::vec3 v_next_x = terrain.getVertex(x + 1, z);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_x.x, v_next_x.y, v_next_x.z);
+            }
+            // Draw vertical lines (along X-axis)
+            if (z < gridSize - 1)
+            {
+                glm::vec3 v_next_z = terrain.getVertex(x, z + 1);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_z.x, v_next_z.y, v_next_z.z);
+            }
+        }
+    }
+    glEnd();
+
+    #endif
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+
+    glPopMatrix();
+}

linux/src/utils.cpp

@@ -0,0 +1,72 @@
+/*
+ * File:        utils.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Utils - perlinNoise is does not use in this project
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "utils.h"
+
+
+uint64_t rdtsc() {
+    return __rdtsc();  // Read Time-Stamp Counter
+}
+
+void checkGLError(const char* operation) {
+    GLenum error = glGetError();
+    if (error != GL_NO_ERROR) {
+        std::cerr << "OpenGL Error after " << operation << ": ";
+        switch (error) {
+            case GL_INVALID_ENUM:
+                std::cerr << "GL_INVALID_ENUM - An unacceptable value is specified for an enumerated argument.";
+                break;
+            case GL_INVALID_VALUE:
+                std::cerr << "GL_INVALID_VALUE - A numeric argument is out of range.";
+                break;
+            case GL_INVALID_OPERATION:
+                std::cerr << "GL_INVALID_OPERATION - The specified operation is not allowed in the current state.";
+                break;
+            case GL_INVALID_FRAMEBUFFER_OPERATION:
+                std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION - The framebuffer object is not complete.";
+                break;
+            case GL_OUT_OF_MEMORY:
+                std::cerr << "GL_OUT_OF_MEMORY - There is not enough memory left to execute the command.";
+                break;
+            case GL_STACK_UNDERFLOW:
+                std::cerr << "GL_STACK_UNDERFLOW - An attempt has been made to perform an operation that would cause the stack to underflow.";
+                break;
+            case GL_STACK_OVERFLOW:
+                std::cerr << "GL_STACK_OVERFLOW - An attempt has been made to perform an operation that would cause a stack overflow.";
+                break;
+            // Add more cases for other specific OpenGL errors if needed
+            default:
+                std::cerr << "Unknown OpenGL error code: " << error;
+        }
+        std::cerr << std::endl;
+    }
+}
+
+// Basic Perlin Noise implementation (simplified 2D version)
+float perlinNoise(float x, float y) {
+    // ... (Implement Perlin noise algorithm here - this is a simplified example) ...
+    // For a complete Perlin noise implementation, refer to online resources.
+    // This is a placeholder for demonstration -  it will produce very basic noise.
+    float value = 0.0f;
+    float frequency = 1.0f;
+    float amplitude = 1.0f;
+    float maxAmplitude = 0.0f;
+
+    for (int i = 0; i < 4; ++i) { // 4 octaves
+        //float sampleX = x * frequency;
+        //float sampleY = y * frequency;
+        //value += glm::perlin(glm::vec2(sampleX, sampleY)) * amplitude; // Using glm::perlin for simplicity
+        maxAmplitude += amplitude;
+        amplitude *= 0.5f; // Reduce amplitude for each octave
+        frequency *= 2.0f; // Increase frequency for each octave
+    }
+    return value / maxAmplitude; // Normalize to [0, 1] range
+}

linux/src/xlogin00.s

@@ -0,0 +1,18 @@
+.intel_syntax noprefix
+.code64
+
+
+.data
+
+
+.text
+
+
+.global updateVertices_simd
+updateVertices_simd:
+    push rbp
+    mov rbp, rsp #asm
+
+    mov rsp, rbp
+    pop rbp
+    ret

windows/.vscode/c_cpp_properties.json

@@ -0,0 +1,21 @@
+{
+    "configurations": [
+        {
+            "name": "Win32",
+            "includePath": [
+                "${workspaceFolder}/**",
+                "${workspaceFolder}\\..\\include"
+            ],
+            "defines": [
+                "_DEBUG",
+                "UNICODE",
+                "_UNICODE"
+            ],
+            "compilerPath": "${workspaceFolder}\\..\\mingw64\\bin\\g++.exe",
+            "cStandard": "c11",
+            "cppStandard": "c++17",
+            "intelliSenseMode": "gcc-x64"
+        }
+    ],
+    "version": 4
+}

windows/.vscode/launch.json

@@ -0,0 +1,38 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "(gdb) Launch",
+        "type": "cppdbg",
+        "request": "launch",
+        "program": "${workspaceFolder}/boat_sim.exe",
+        "args": [],
+        "stopAtEntry": true,
+        "cwd": "${workspaceFolder}",
+        "environment": [],
+        "externalConsole": false,
+        "preLaunchTask": "Build",
+        "windows": {
+          "MIMode": "gdb",
+          "miDebuggerPath": "${workspaceFolder}/../mingw64/bin/gdb.exe",
+          "setupCommands": [
+            {
+              "description": "Enable pretty-printing for gdb",
+              "text": "-enable-pretty-printing",
+              "ignoreFailures": true
+            },
+            {
+              "description": "Reduce gdb verbosity",
+              "text": "set print thread-events on",
+              "ignoreFailures": true
+            }
+          ],
+          "logging": {
+            "trace": false,
+            "traceResponse": false,
+            "engineLogging": false
+          }
+        }
+      }
+    ]
+  }

windows/.vscode/settings.json

@@ -0,0 +1,63 @@
+{
+    "files.associations": {
+        "iostream": "cpp",
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "complex": "cpp",
+        "concepts": "cpp",
+        "condition_variable": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "map": "cpp",
+        "set": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "fstream": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "mutex": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "semaphore": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "stop_token": "cpp",
+        "streambuf": "cpp",
+        "thread": "cpp",
+        "cinttypes": "cpp",
+        "typeinfo": "cpp"
+    }
+}

windows/.vscode/tasks.json

@@ -0,0 +1,41 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+        {
+            "label": "Build",
+            "type": "shell",
+            "command": "${workspaceFolder}/../mingw64/bin/mingw32-make.exe", // Or "mingw32-make" if you are using MinGW on Windows and "make" is not in your PATH
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
+        },
+        {
+            "label": "Clean (Windows)",
+            "type": "shell",
+            "command": "del",
+            "args": [
+                "build\\*.o",
+                "boat_sim.exe"
+            ],
+            "problemMatcher": [],
+            "group": "cleanup",
+            "detail": "Deletes all object files (*.o) in the current directory"
+        },
+        {
+            "label": "Run",
+            "type": "shell",
+            "command": "boat_sim.exe",
+            "options": {
+                "cwd": "${workspaceFolder}"
+            },
+            "dependsOn": "Build"
+        }
+    ]
+}

windows/Makefile

@@ -0,0 +1,61 @@
+# Makefile for boat_sim project
+
+# Compiler and flags
+CXX = g++
+CXXFLAGS = -Wall -g  -mavx -msse4 # -Wall for more warnings, -g for debugging symbols
+INC_DIR = include
+LIBS = -lfreeglut -lglew32 -lSOIL -lopengl32 -lglu32
+LIB_DIR = ..\libs
+LDFLAGS = -L$(LIB_DIR)
+
+# Directories
+SRC_DIR = src
+BUILD_DIR = build
+
+# Source files - includes .cpp and .s from src and src_project
+SOURCES = $(wildcard $(SRC_DIR)/*.cpp) $(wildcard $(SRC_DIR)/src_project/*.cpp) $(wildcard $(SRC_DIR)/*.s) $(wildcard $(SRC_DIR)/src_project/*.s)
+
+# Object files in build directory - creates corresponding object file paths in build dir
+OBJECTS = $(patsubst $(SRC_DIR)/%.cpp,$(BUILD_DIR)/%.o,$(filter $(SRC_DIR)/%.cpp,$(SOURCES)))
+OBJECTS += $(patsubst $(SRC_DIR)/%.s,$(BUILD_DIR)/%.o,$(filter $(SRC_DIR)/%.s,$(SOURCES)))
+
+
+EXECUTABLE = boat_sim
+EXECUTABLE_PATH = $(EXECUTABLE)
+
+# Default target
+all: $(EXECUTABLE_PATH)
+
+# Rule to create the executable in build dir
+$(EXECUTABLE_PATH): $(OBJECTS)
+	$(CXX) -o $@ $^ $(LDFLAGS) $(LIBS)
+
+# General rule to compile/assemble source files to object files in build dir
+# For .cpp files in src directory
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.cpp
+	$(CXX) $(CXXFLAGS) -I$(INC_DIR) -c $< -o $@
+
+
+
+# For .s files in src directory - USING 'as' directly
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.s
+	$(CXX) -g -c $< -o $@ 
+
+
+
+# Clean target
+clean:
+	rm -rf $(BUILD_DIR)
+
+# Debug build target
+debug: CXXFLAGS += -DDEBUG -g
+
+# Run target
+run: all
+	./$(EXECUTABLE_PATH)
+
+# Run debug target
+rundebug: debug
+	gdb ./$(EXECUTABLE_PATH)
+
+.PHONY: all clean debug run rundebug

windows/assets/models/boat.mtl

@@ -0,0 +1,28 @@
+# 3ds Max Wavefront OBJ Exporter v0.97b - (c)2007 guruware
+# File Created: 08.06.2011 15:26:00
+
+newmtl _10634_SpeedBoat_v01_LOD310634_SpeedBoat_v01
+	Ns 53.0000
+	Ni 1.5000
+	d 1.0000
+	Tr 0.0000
+	Tf 1.0000 1.0000 1.0000 
+	illum 2
+	Ka 0.5882 0.5882 0.5882
+	Kd 0.5882 0.5882 0.5882
+	Ks 0.2000 0.2000 0.2000
+	Ke 0.0000 0.0000 0.0000
+	map_Ka boat.jpg
+	map_Kd boat.jpg
+
+newmtl glass
+	Ns 80.0000
+	Ni 1.5000
+	d 0.2000
+	Tr 0.8000
+	Tf 0.2000 0.2000 0.2000 
+	illum 2
+	Ka 0.5882 0.5882 0.5882
+	Kd 0.5882 0.5882 0.5882
+	Ks 0.5000 0.5000 0.5000
+	Ke 0.0000 0.0000 0.0000

windows/assets/shaders/ocean_fragment_shader.glsl

@@ -0,0 +1,54 @@
+#version 330 core
+// Fragment Shader for Ocean Rendering with Texture Normals
+
+in vec3 NormalInterp; // **IN variable declaration - crucial!**
+
+// Input from Vertex Shader
+in vec2 TexCoord;
+in vec3 FragPosWorld;
+in vec3 NormalWorld;
+
+// Output fragment color
+out vec4 FragColor;
+
+// Uniforms (textures, lighting parameters, camera position)
+uniform sampler2D oceanTexture;    // Sampler for ocean color texture
+uniform sampler2D normalMap;       // Sampler for normal map texture
+uniform vec3 lightDir;          // Directional light direction (world space)
+uniform vec3 lightColor;        // Light color
+uniform vec3 viewPosWorld;      // Camera position in world space
+
+void main() {
+    // 1. Sample textures
+    vec3 albedoColor = texture(oceanTexture, TexCoord).rgb; // Sample ocean color texture
+    //vec3 normalMapSample = texture(normalMap, TexCoord).rgb; // Sample normal map
+
+    // 2. Unpack and transform normal from normal map (Tangent Space to World Space - Simplified)
+    //vec3 normalMapNormal = normalize(normalMapSample * 2.0 - 1.0); // Unpack from [0, 1] to [-1, 1] and normalize
+    vec3 normalWorld = normalize(NormalInterp); // Get interpolated geometric normal from vertex shader
+
+    // **Basic Tangent Space Normal Mapping Approximation:**
+    // For truly correct tangent-space normal mapping, you'd need to construct a proper TBN matrix.
+    vec3 finalNormal = normalize(normalWorld ); // **Blend/Perturb geometric normal with texture normal**
+
+
+    // 3. Lighting calculations (Blinn-Phong example)
+    vec3 lightDirNorm = normalize(lightDir);
+    vec3 viewDirNorm = normalize(viewPosWorld - FragPosWorld);
+    vec3 reflectDir = reflect(-lightDirNorm, finalNormal);
+
+    // Diffuse component
+    float diff = max(dot(finalNormal, lightDirNorm), 0.0);
+    vec3 diffuse = diff * lightColor * albedoColor;
+
+    // Specular component (Blinn-Phong)
+    float spec = pow(max(dot(viewDirNorm, reflectDir), 0.0), 32.0);
+    vec3 specular = spec * lightColor * vec3(0.8); // Example specular color
+
+    // Ambient component
+    vec3 ambient = 0.3 * lightColor * albedoColor; // Example ambient
+
+    // 4. Combine lighting components for final color
+    vec3 finalColor = ambient + diffuse + specular;
+    FragColor = vec4(finalColor, 1.0); // Output final fragment color
+}

windows/assets/shaders/ocean_vertex_shader.glsl

@@ -0,0 +1,34 @@
+#version 330 core
+// Vertex Shader for Ocean Rendering
+
+// Input vertex attributes (from VBOs)
+layout (location = 0) in vec3 aPos;      // Vertex position (from Ocean::vertices VBO)
+layout (location = 1) in vec3 aNormal;   // Vertex normal (from Ocean::normals VBO)
+layout (location = 2) in vec2 aTexCoord; // Texture coordinates (from Ocean::texCoords VBO)
+
+// Output to Fragment Shader
+out vec2 TexCoord;
+out vec3 FragPosWorld;     // Fragment position in world space
+out vec3 NormalWorld;      // Normal vector in world space
+
+out vec3 NormalInterp; // **OUT variable declaration - crucial!**
+
+// Uniforms (matrices, light parameters, etc.)
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat3 normalMatrix; // Normal matrix for correct normal transformation
+
+void main() {
+    // 1. Transform vertex position to clip space
+    gl_Position = projection * view  * vec4(aPos, 1.0);
+
+    // 2. Pass texture coordinates to fragment shader
+    TexCoord = aTexCoord;
+
+    // 3. Calculate fragment position in world space
+    FragPosWorld = vec3(model * vec4(aPos, 1.0));
+
+    // 4. Transform normal vector to world space using the Normal Matrix
+    NormalWorld = normalize(normalMatrix * aNormal);
+}

windows/assets/shaders/terrain_fragment_shader.glsl

@@ -0,0 +1,50 @@
+#version 330 core
+// Fragment Shader for Terrain Rendering
+
+in vec3 NormalInterp; // **IN variable declaration - crucial!**
+
+
+in vec2 TexCoord;
+in vec3 FragPosWorld;
+in vec3 NormalWorld;
+
+out vec4 FragColor;
+
+uniform sampler2D terrainTexture; // Sampler for terrain color texture (no normal map for now)
+uniform sampler2D heightMapTexture; // **New: Sampler for heightmap texture**
+
+uniform vec3 lightDir;
+uniform vec3 lightColor;
+uniform vec3 viewPosWorld;
+
+void main() {
+    // 1. Sample terrain texture
+    vec3 albedoColor = texture(terrainTexture, TexCoord).rgb;
+    float heightValue = texture(heightMapTexture, TexCoord).r; // **Sample heightmap (Red channel = grayscale height)**
+
+    // 2. Lighting calculations (Blinn-Phong - similar to ocean shader)
+    vec3 normal = normalize(NormalWorld); // Use geometric normal for terrain
+    vec3 lightDirNorm = normalize(lightDir);
+    vec3 viewDirNorm = normalize(viewPosWorld - FragPosWorld);
+    vec3 reflectDir = reflect(-lightDirNorm, normal);
+
+    // Diffuse component
+    float diff = max(dot(normal, lightDirNorm), 0.0);
+    vec3 diffuse = diff * lightColor * albedoColor;
+
+    // Specular component
+    float spec = pow(max(dot(viewDirNorm, reflectDir), 0.0), 16.0); // Adjust shininess (exponent)
+    vec3 specular = spec * lightColor * vec3(0.3); // Example specular color - less shiny than ocean
+
+    // Ambient component
+    vec3 ambient = 0.2 * lightColor * albedoColor;
+
+    vec3 lowColor = vec3(0.2, 0.3, 0.05); // Darker green/brown for lower areas
+    vec3 highColor = vec3(0.5, 0.7, 0.2); // Lighter green for higher areas
+    vec3 heightBasedColor = mix(lowColor, highColor, heightValue); // Linear interpolation based on heightValue
+
+
+    // 4. Combine lighting components for final color
+    vec3 finalColor = ambient + diffuse + specular;
+    FragColor = vec4(finalColor * heightBasedColor, 1.0);
+}

windows/assets/shaders/terrain_vertex_shader.glsl

@@ -0,0 +1,22 @@
+#version 330 core
+// Vertex Shader for Terrain Rendering
+
+layout (location = 0) in vec3 aPos;      // Vertex position
+layout (location = 1) in vec3 aNormal;   // Vertex normal
+layout (location = 2) in vec2 aTexCoord; // Texture coordinates
+
+out vec2 TexCoord;
+out vec3 FragPosWorld;
+out vec3 NormalWorld;
+
+uniform mat4 model;
+uniform mat4 view;
+uniform mat4 projection;
+uniform mat3 normalMatrix;
+
+void main() {
+    gl_Position = projection * view  * vec4(aPos, 1.0);
+    TexCoord = aTexCoord;
+    FragPosWorld = vec3(model * vec4(aPos, 1.0));
+    NormalWorld = normalize(normalMatrix * aNormal);
+}

windows/include/Boat.h

@@ -0,0 +1,66 @@
+#ifndef BOAT_H
+#define BOAT_H
+
+#include <glm/glm.hpp>
+#include <glm/gtc/quaternion.hpp>
+#include <vector>
+#include "Input.h"
+#include "Ocean.h"
+#include <string>
+#include <tiny_obj_loader.h> // Include tinyobjloader
+
+class Boat {
+public:
+    Boat();
+    ~Boat();
+
+    bool init(const char* modelPath, const char* texturePath); // Pass model and texture paths
+    void cleanup();
+    void update(const Input& input, const Ocean& ocean, float deltaTime);
+
+    glm::vec3 getPosition() const { return position; }
+    glm::quat getRotation() const { return rotation; }
+
+    glm::vec3 getBoundingBoxMin() const { return boundingBoxMin; } // **Getter for boundingBoxMin**
+    glm::vec3 getBoundingBoxMax() const { return boundingBoxMax; } // **Getter for boundingBoxMax**
+
+    // Getters for model data to pass to Renderer
+    const std::vector<glm::vec3>& getVertices() const { return vertices; }
+    const std::vector<glm::vec3>& getNormals() const { return normals; }
+    const std::vector<glm::vec2>& getTexCoords() const { return texCoords; }
+    const std::string& getTexturePath() const { return boatTexturePath; } // Getter for texture path
+    const std::vector<tinyobj::material_t>& getMaterials() const { return materials; } // Getter for materials
+    const std::vector<int>& getMaterialIndices() const { return materialIndices; } // Getter for materials
+
+    // New: Getter and Setter for boatScale
+    float getScale() const { return boatScale; }
+    void setScale(float scale) { boatScale = scale; }
+
+
+private:
+    glm::vec3 position;
+    glm::quat rotation;
+    float speed;
+    float steeringSpeed;
+
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec3> normals;
+    std::vector<glm::vec2> texCoords;
+    std::vector<int> materialIndices; // New: Store material indices per vertex
+    std::vector<tinyobj::material_t> materials; // New: Store materials
+
+
+    void handleInput(const Input& input, float deltaTime);
+    void applyWaveMotion(const Ocean& ocean);
+    bool loadModel(const char* path); // Function to load OBJ model
+    std::string boatTexturePath; // Store texture path for Renderer to access
+    glm::vec3 boundingBoxMin;
+    glm::vec3 boundingBoxMax;
+    int getGridIndex(int x, int z) const;         // Helper function to get 1D index from 2D grid indices
+
+    float boatScale;
+
+
+};
+
+#endif // BOAT_H

windows/include/Camera.h

@@ -0,0 +1,41 @@
+// Camera.h
+#ifndef CAMERA_H
+#define CAMERA_H
+
+#include <glm/glm.hpp>
+#include "Input.h" // Optional Shader class
+
+class Camera {
+public:
+    Camera();
+    ~Camera();
+
+    void init();
+    void update(const Input& input, const glm::vec3& boatPosition);
+    void lookAt() const;
+
+    void setAspectRatio(float ratio) { aspectRatio = ratio; }
+    glm::vec3 getPosition() const { return position; } // Public getter for position
+    glm::mat4 getViewMatrix() const; // **Declare getViewMatrix() method**
+
+        // New: Camera Rotation Control
+        void handleMouseInput(const Input& input, float deltaTime);
+        void rotateYaw(float angle);
+        void rotatePitch(float angle);
+private:
+    glm::vec3 position;
+    glm::vec3 target; // Point to look at
+    glm::vec3 up;
+    float aspectRatio;
+    float fov;
+    float nearPlane;
+    float farPlane;
+
+
+    // New: Camera Rotation State
+    float yawAngle=0.0f;
+    float pitchAngle=0.0f;
+    float rotationSpeed;
+};
+
+#endif // CAMERA_H

windows/include/Game.h

@@ -0,0 +1,47 @@
+// Game.h
+#ifndef GAME_H
+#define GAME_H
+#include <GL/glew.h>
+#include <GL/freeglut.h>
+#include "Renderer.h"
+#include "Input.h"
+#include "Ocean.h"
+#include "Boat.h"
+#include "Camera.h"
+#include <cstdio>
+#include <iostream>
+#include "Terrain.h" // Include Terrain header
+
+class Game {
+public:
+    Game();
+    ~Game();
+
+    bool init(int argc, char** argv);
+    void run();
+    void cleanup();
+
+private:
+    Renderer renderer;
+    Input input;
+    Ocean ocean;
+    Boat boat;
+    Camera camera;
+    Terrain terrain; // Add Terrain member
+
+
+    static void displayCallback();
+    static void reshapeCallback(int width, int height);
+    static void keyboardCallback(unsigned char key, int x, int y);
+    static void keyboardUpCallback(unsigned char key, int x, int y);
+    static void specialCallback(int key, int x, int y);
+    static void specialUpCallback(int key, int x, int y);
+    static void mouseCallback(int button, int state, int x, int y);
+    static void motionCallback(int x, int y);
+    static void timerCallback(int value);
+    static void updateGame();
+
+    static Game* instance; // Singleton for callbacks to access game instance
+};
+
+#endif // GAME_H

windows/include/Input.h

@@ -0,0 +1,45 @@
+// Input.h
+#ifndef INPUT_H
+#define INPUT_H
+
+#include <set>
+
+class Input {
+public:
+    Input();
+    ~Input();
+
+    void init();
+    void update();
+
+    void handleKeyPress(unsigned char key);
+    void handleKeyRelease(unsigned char key);
+    void handleSpecialKeyPress(int key);
+    void handleSpecialKeyRelease(int key);
+    void handleMouseClick(int button, int state, int x, int y);
+    void handleMouseMove(int x, int y);
+
+    bool isKeyDown(unsigned char key) const;
+    bool isSpecialKeyDown(int key) const;
+    // Mouse input methods if needed
+
+    // New: Mouse Input Methods
+    bool isMouseButtonDown(int button) const { return mouseButtonsDown[button]; }
+    int getMouseX() const { return mouseX; }
+    int getMouseY() const { return mouseY; }
+    int getMouseDeltaX() const { return mouseDeltaX; }
+    int getMouseDeltaY() const { return mouseDeltaY; }
+
+
+private:
+    std::set<unsigned char> keysDown;
+    std::set<int> specialKeysDown;
+    // Mouse state variables if needed
+
+        bool mouseButtonsDown[5]; // Up to 5 mouse buttons (GLUT_LEFT_BUTTON, etc.)
+    int mouseX, mouseY;        // Current mouse position
+    int lastMouseX, lastMouseY; // Last frame's mouse position
+    int mouseDeltaX, mouseDeltaY; // Mouse movement delta since last frame
+};
+
+#endif // INPUT_H

windows/include/Ocean.h

@@ -0,0 +1,94 @@
+// Ocean.h
+#ifndef OCEAN_H
+#define OCEAN_H
+
+#include <glm/glm.hpp>
+#include <vector>
+#include <GL/glew.h> // Include GLEW for OpenGL types like GLuint
+#include "utils.h" // **Include utils.h to use checkGLError**
+#include <immintrin.h>
+#include <x86intrin.h>
+
+
+
+#define ASM_TYPE CLEAR_ASM
+
+
+#define INTRINSIC 1
+#define CLEAR_ASM 2
+
+
+// Structure to hold parameters for a single Gerstner wave component
+struct GerstnerWave {
+    float amplitude;    // Wave amplitude (height)
+    float wavelength;   // Wavelength (distance between crests)
+    float speed;        // Wave speed
+    glm::vec2 direction; // Wave direction (normalized 2D vector in XZ plane)
+    float phase;        // Phase offset
+};
+
+
+class Ocean {
+public:
+    Ocean(int gridSize);
+    ~Ocean();
+
+    bool init();
+    void cleanup();
+    void update(float deltaTime);
+
+    glm::vec3 getVertex(int x, int z) const;
+    float getWaveHeight(float x, float z, float time) const;
+    glm::vec3 getWaveNormal(float x, float z, float time) const; // Calculate wave normal
+
+    void setGridSize(int newGridSize); // Setter function
+    int getGridSize() const { return gridSize; }
+    float getGridSpacing() const { return gridSpacing; }
+    GLuint getVAO() const;                                // Get the Vertex Array Object ID
+    GLuint getIndexCount() const;                         // Get the number of indices for rendering
+    float time;
+
+
+private:
+    int gridSize;
+    float gridSpacing;
+    std::vector<glm::vec3> vertices; // Store vertices for optimization (optional)
+    std::vector<GerstnerWave> gerstnerWaves; // Vector to store multiple Gerstner wave components
+
+    // Wave parameters (adjustable)
+    float amplitude;
+    float wavelength;
+    float frequency;
+    glm::vec2 direction; // Wave direction
+    float phase; // Initial phase
+
+
+    GLuint vertexBufferID;    // VBO ID for vertex positions
+    GLuint normalBufferID;    // VBO ID for vertex normals
+    GLuint texCoordBufferID;  // VBO ID for texture coordinates
+    GLuint indexBufferID;     // IBO ID for indices
+    GLuint vaoID;             // VAO ID (Vertex Array Object)
+    unsigned int indexCount;    // Number of indices for rendering
+
+    std::vector<float> originalWorldX;        // Vector to store original undisplaced World X coordinates
+    std::vector<float> originalWorldZ;        // Vector to store original undisplaced World Z coordinates
+
+    float baseAmplitude;  // Base (maximum) wave amplitude for periodic modulation
+
+
+    void generateGrid();
+    void createBuffers();                        // Create and populate VBOs and IBO
+    void updateBuffers(const std::vector<glm::vec3>& updatedVertices, const std::vector<glm::vec3>& updatedNormals); // Update VBO data
+    void updateVertices(std::vector<glm::vec3> * updatedVertices, std::vector<glm::vec3> * updatedNormals, float time); // Update vertex Y positions based on wave function
+    
+#if ASM_TYPE==CLEAR_ASM
+#else
+    void updateVertices_simd(float* updatedVertices_array, float* updatedNormals_array, size_t numVertices, float time); // Modified signature for C++ as well (for consistency or if you want to use float arrays in C++ SIMD too)
+#endif
+    
+    int getGridIndex(int x, int z) const;         // Helper function to get 1D index from 2D grid indices
+    float getGerstnerWaveHeight(const GerstnerWave& wave, float x, float z, float time) const; // Calculate height for a single Gerstner wave
+    glm::vec3 getGerstnerWaveDisplacement(const GerstnerWave& wave, float x, float z, float time) const; // Calculate horizontal displacement for a Gerstner wave
+};
+
+#endif // OCEAN_H

windows/include/Renderer.h

@@ -0,0 +1,53 @@
+// Renderer.h
+#ifndef RENDERER_H
+#define RENDERER_H
+
+#include <GL/glew.h>
+#include <GL/freeglut.h>
+#include "Ocean.h"
+#include "Boat.h"
+#include "Camera.h"
+#include "Shader.h" // Optional Shader class
+#include "Terrain.h" // Include Terrain header
+
+
+#define SHOW_GRID 0
+#define SHOW_NORM 0
+#define SHOW_BOUDING_BOX 1
+
+class Renderer {
+public:
+    Renderer();
+    ~Renderer();
+    GLuint oceanTextureID;
+    GLuint boatTextureID;
+    GLuint terrainTextureID; // Texture ID for terrain
+    GLuint heightMapTextureID; // **Add heightMapTextureID**
+    bool init();
+    void cleanup();
+    void renderScene(const Ocean &ocean, const Boat &boat, const Camera &camera, const Terrain &Terrain);
+    void reshape(int width, int height);
+    void drawOcean(const Ocean& ocean, const Camera& camera); // Camera argument added
+    GLuint getTerrainTextureID() const { return terrainTextureID; } // Getter for terrain texture ID
+
+private:
+
+    // Shader shaderProgram; // Optional shader program
+    GLuint normalMapTextureID; 
+    Shader oceanShader; // Shader program for ocean
+    Shader terrainShader; // **Add terrainShader member variable**
+
+    std::string lastBoatTexturePath = "";
+
+    bool loadTexture(const char* filename, GLuint& textureID);
+    void setupLighting();
+    void drawBoat(const Boat& boat);
+    void drawMesh(const std::vector<glm::vec3>& vertices, const std::vector<glm::vec3>& normals, const std::vector<glm::vec2>& texCoords,
+                  const std::vector<int>& materialIndices, const std::vector<tinyobj::material_t>& materials); // Modified drawMesh
+
+    void drawMeshVBO(const Ocean& ocean); // **Declare drawMeshVBO**
+    void drawTerrain(const Terrain& terrain, const Camera& camera);
+    void drawMeshTerainVBO(const Terrain& terrain);
+};
+
+#endif // RENDERER_H

windows/include/Shader.h

@@ -0,0 +1,39 @@
+#ifndef SHADER_H
+#define SHADER_H
+
+#include <string>
+#include <GL/glew.h> // Include GLEW for OpenGL types
+#include <glm/glm.hpp> // **ADD THIS LINE - Include GLM header!**
+#include <glm/gtc/type_ptr.hpp>
+
+
+
+class Shader {
+public:
+    Shader(); // Constructor
+    ~Shader(); // Destructor
+
+    bool loadShader(const char* vertexShaderPath, const char* fragmentShaderPath); // Load and compile shaders from files
+    bool isLoaded() const { return programID != 0; } // Check if shader program is loaded
+
+    void use();       // Use (activate) the shader program
+    void unuse();     // Unuse (deactivate) the shader program
+    void cleanup();   // Release shader resources
+
+    // Uniform setting functions (add more as needed for different uniform types)
+    void setInt(const std::string& name, int value) const;
+    void setFloat(const std::string& name, float value) const;
+    void setVec3(const std::string& name, const glm::vec3& value) const;
+    void setMat4(const std::string& name, const glm::mat4& mat) const;
+    void setMat3(const std::string& name, const glm::mat3& mat) const;
+
+private:
+    GLuint vertexShaderID;   // Vertex shader object ID
+    GLuint fragmentShaderID; // Fragment shader object ID
+    GLuint programID;        // Shader program ID
+
+    bool compileShader(GLuint& shaderID, GLenum shaderType, const char* shaderPath);
+    bool linkShaderProgram();
+};
+
+#endif // SHADER_H

windows/include/Terrain.h

@@ -0,0 +1,43 @@
+// include/Terrain.h
+#ifndef TERRAIN_H
+#define TERRAIN_H
+
+#include <glm/glm.hpp>
+#include <vector>
+#include <GL/glew.h> // Include GLEW for OpenGL types like GLuint
+#include "Shader.h"
+class Terrain {
+public:
+    Terrain(int gridSize, float gridSpacing);
+    ~Terrain();
+
+    bool init(GLuint heightMapTextureID);
+    void cleanup();
+
+    glm::vec3 getVertex(int x, int z) const; // Get vertex position at grid index (x, z)
+
+    int getGridSize() const { return gridSize; }
+    float getGridSpacing() const { return gridSpacing; }
+    GLuint getVAO() const { return vaoID; }
+    GLuint getIndexCount() const { return indexCount; }
+    glm::vec3 getNormal(float x, float z) const;
+private:
+    int gridSize;
+    float gridSpacing;
+    std::vector<glm::vec3> vertices;
+    std::vector<glm::vec3> normals;
+    std::vector<glm::vec2> texCoords;
+    GLuint vertexBufferID;
+    GLuint normalBufferID;
+    GLuint texCoordBufferID;
+    GLuint indexBufferID;
+    GLuint vaoID;
+    unsigned int indexCount;
+
+
+    void generateGrid(GLuint heightMapTextureID); // Generate the initial grid of vertices
+    void createBuffers(); // Create and populate VBOs and IBO
+    void updateBuffers();   // Update VBO data (not needed for static terrain in this example, but good to have)
+};
+
+#endif // TERRAIN_H

windows/include/utils.h

@@ -0,0 +1,15 @@
+#ifndef UTILS_H
+#define UTILS_H
+
+#include <GL/glew.h>
+#include <iostream>
+#include <glm/glm.hpp>
+#include <x86intrin.h>
+
+
+// Helper function to check for OpenGL errors and print a message
+void checkGLError(const char* operation);
+float perlinNoise(float x, float y); // Placeholder declaration
+
+uint64_t rdtsc();
+#endif // UTILS_H

windows/src/Boat.cpp

@@ -0,0 +1,215 @@
+/*
+ * File:        Boat.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Class for representng boat
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+
+
+#include "Boat.h"
+#include <iostream>
+#define TINYOBJLOADER_IMPLEMENTATION
+#include <tiny_obj_loader.h> // Include tinyobjloader
+#include <glm/gtc/type_ptr.hpp> // For value_ptr (if needed for debugging)
+
+Boat::Boat() : position(0.0f, 0.5f, 0.0f), rotation(glm::quat(1.0f, 0.0f, 0.0f, 0.0f)), speed(0.0f), steeringSpeed(1.0f), materials(), boatScale(1.0f) {} // Initialize boatScale to 1.0f
+Boat::~Boat() {}
+
+bool Boat::init(const char* modelPath, const char* texturePath) {
+    materials.clear(); // Explicitly clear materials before loading model
+    if (!loadModel(modelPath)) {
+        std::cerr << "Error loading boat model: " << modelPath << std::endl;
+        return false;
+    }
+    boatTexturePath = texturePath;
+    return true;
+}
+
+void Boat::cleanup() {
+    // No dynamic memory cleanup in this simple example, but if you used dynamic allocation in loadModel, clean it up here.
+}
+
+void Boat::update(const Input& input, const Ocean& ocean, float deltaTime) {
+    handleInput(input, deltaTime);
+    applyWaveMotion(ocean);
+}
+
+void Boat::handleInput(const Input& input, float deltaTime) {
+    if (input.isKeyDown('w')) {
+        speed += 0.5f * deltaTime; // Accelerate forward
+    }
+    if (input.isKeyDown('s')) {
+        speed -= 0.5f * deltaTime; // Decelerate/reverse
+    }
+    if (input.isKeyDown('a')) {
+        rotation = glm::rotate(rotation, steeringSpeed * deltaTime, glm::vec3(0.0f, 1.0f, 0.0f)); // Steer left
+    }
+    if (input.isKeyDown('d')) {
+        rotation = glm::rotate(rotation, -steeringSpeed * deltaTime, glm::vec3(0.0f, 1.0f, 0.0f)); // Steer right
+    }
+
+    speed = glm::clamp(speed, -0.5f, 4.0f); // Clamp speed
+    if (!input.isKeyDown('w') && !input.isKeyDown('s')) {
+        speed *= (1.0f - 0.5f * deltaTime); // Natural deceleration
+        if (fabs(speed) < 0.01f) speed = 0.0f; // Stop completely
+    }
+
+    // Move boat forward/backward based on rotation and speed
+    glm::vec3 forwardVector = rotation * glm::vec3(0.0f, 0.0f, -1.0f); // Boat's forward direction
+    position += forwardVector * speed * deltaTime;
+}
+
+void Boat::applyWaveMotion(const Ocean& ocean) {
+    // Sample wave height at boat's position
+    position.y = ocean.getWaveHeight(position.x, position.z, ocean.time);
+
+    // Get wave normal
+    glm::vec3 waveNormal = ocean.getWaveNormal(position.x, position.z, ocean.time);
+    //std::cout << "Wave Normal: (" << waveNormal.x << ", " << waveNormal.y << ", " << waveNormal.z << ")" << std::endl;
+
+    // Get current boat forward direction
+    glm::vec3 currentBoatForward = rotation * glm::vec3(0.0f, 0.0f, -1.0f);
+    glm::vec3 horizontalForward = glm::normalize(glm::vec3(currentBoatForward.x, 0.0f, currentBoatForward.z));
+    if (horizontalForward == glm::vec3(0.0f)) {
+        horizontalForward = glm::vec3(0.0f, 0.0f, -1.0f); // Default if boat is pointing straight up/down
+    }
+
+    glm::vec3 targetUp = waveNormal;
+    glm::vec3 targetForward = glm::normalize(glm::cross(glm::cross(targetUp, horizontalForward), targetUp)); // Project horizontalForward onto plane perpendicular to targetUp
+
+    if (targetForward == glm::vec3(0.0f)) {
+        targetForward = horizontalForward; // Fallback if projection fails (waveNormal is vertical or horizontalForward is parallel to waveNormal somehow)
+    }
+
+    glm::vec3 targetRight = glm::normalize(glm::cross(targetForward, targetUp));
+
+    // Create rotation matrix from basis vectors
+    glm::mat3 targetRotationMatrix(targetRight, targetUp, -targetForward); // Boat forward is -Z
+    glm::quat targetRotation = glm::quat_cast(targetRotationMatrix);
+
+    rotation = glm::slerp(rotation, targetRotation, 0.1f);
+}
+
+
+bool Boat::loadModel(const char* path) {
+    tinyobj::attrib_t attrib;
+    std::vector<tinyobj::shape_t> shapes;
+    std::vector<tinyobj::material_t> materials;
+    std::string warn, err;
+
+    // Extract the directory path from the OBJ file path
+    std::string inputfile_dir = "./";
+    std::string path_str = path;
+    size_t last_slash_pos = path_str.find_last_of("/\\"); // Handle both / and \ path separators
+    if (last_slash_pos != std::string::npos) {
+        inputfile_dir = path_str.substr(0, last_slash_pos + 1); // Include the last slash
+    }
+
+    bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path, inputfile_dir.c_str()); // Pass mtl_basepath
+
+    if (!warn.empty()) {
+        std::cout << "tinyobjloader warning: " << warn << std::endl;
+    }
+
+    if (!err.empty()) {
+        std::cerr << "tinyobjloader error: " << err << std::endl;
+    }
+
+    if (!ret) {
+        return false;
+    }
+
+    vertices.clear();
+    normals.clear();
+    texCoords.clear();
+    materialIndices.clear(); // Clear material indices
+    // Loop through each shape in the OBJ file
+    for (const auto& shape : shapes) {
+        // Loop over faces(polygon)
+        for (size_t f = 0; f < shape.mesh.indices.size() / 3; f++) {
+            int material_index = shape.mesh.material_ids[f]; // Get material index for this face
+
+            // Loop over vertices in the face (triangle)
+            for (size_t v = 0; v < 3; v++) {
+                tinyobj::index_t idx = shape.mesh.indices[3 * f + v];
+
+                tinyobj::real_t vx = attrib.vertices[3 * idx.vertex_index + 0];
+                tinyobj::real_t vy = attrib.vertices[3 * idx.vertex_index + 1];
+                tinyobj::real_t vz = attrib.vertices[3 * idx.vertex_index + 2];
+                vertices.push_back(glm::vec3(vx, vy, vz));
+
+                if (!attrib.normals.empty()) {
+                    tinyobj::real_t nx = attrib.normals[3 * idx.normal_index + 0];
+                    tinyobj::real_t ny = attrib.normals[3 * idx.normal_index + 1];
+                    tinyobj::real_t nz = attrib.normals[3 * idx.normal_index + 2];
+                    normals.push_back(glm::vec3(nx, ny, nz));
+                } else {
+                    normals.push_back(glm::vec3(0.0f, 1.0f, 0.0f)); // Default normal if no normals in OBJ
+                }
+
+                if (!attrib.texcoords.empty()) {
+                    tinyobj::real_t tx = attrib.texcoords[2 * idx.texcoord_index + 0];
+                    tinyobj::real_t ty = attrib.texcoords[2 * idx.texcoord_index + 1];
+                    texCoords.push_back(glm::vec2(tx, 1.0f - ty)); // Flip V texture coord (OpenGL convention)
+                } else {
+                    texCoords.push_back(glm::vec2(0.0f, 0.0f)); // Default texcoord if no texcoords in OBJ
+                }
+                materialIndices.push_back(material_index); // Store material index for this vertex
+            }
+        }
+    }
+
+    if (ret) {
+
+        glm::quat modelRotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f); // Identity quaternion (no rotation initially)
+
+        // **Experiment with these rotations to find the correct orientation!**
+        // Example 1: Rotate 180 degrees around Y-axis (to flip the boat horizontally if it's backwards)
+        modelRotation = glm::rotate(modelRotation, glm::radians(180.0f), glm::vec3(0.0f, 1.0f, 0.0f)); // Rotate 180 degrees yaw
+        modelRotation = glm::rotate(modelRotation, glm::radians(180.f), glm::vec3(1.0f, 0.0f, 0.0f)); // Yaw rotation (example: 0 degrees)
+        modelRotation = glm::rotate(modelRotation, glm::radians(90.0f), glm::vec3(1.0f, 0.0f, 0.0f)); // Pitch rotation (example: 0 degrees)
+        // Example 2: Rotate around X-axis (Pitch) - Adjust angle as needed
+        // modelRotation = glm::rotate(modelRotation, glm::radians(0.0f), glm::vec3(1.0f, 0.0f, 0.0f)); // No pitch rotation in this example
+
+        // Example 3: Rotate around Z-axis (Roll) - Adjust angle as needed
+        // modelRotation = glm::rotate(modelRotation, glm::radians(0.0f), glm::vec3(0.0f, 0.0f, 1.0f)); // No roll rotation in this example
+
+
+        // **Apply rotation to vertices AFTER model loading**
+        for (glm::vec3& vertex : vertices) {
+            vertex = modelRotation * vertex; // Apply rotation to each vertex in model space
+        }
+
+
+
+
+
+        // **Calculate Bounding Box AFTER model loading**
+        if (!vertices.empty()) {
+            boundingBoxMin = vertices[0]; // Initialize with first vertex
+            boundingBoxMax = vertices[0];
+            std::cout << "Boat Bounding Box Min: (" << boundingBoxMin.x << ", " << boundingBoxMin.y << ", " << boundingBoxMin.z << ")" << std::endl;
+
+            // **Bounding Box Calculation Loop - This is where boundingBoxMin and boundingBoxMax are calculated and set**
+            for (const auto& vertex : vertices) {
+                boundingBoxMin.x = glm::min(boundingBoxMin.x, vertex.x);
+                boundingBoxMin.y = glm::min(boundingBoxMin.y, vertex.y);
+                boundingBoxMin.z = glm::min(boundingBoxMin.z, vertex.z);
+
+                boundingBoxMax.x = glm::max(boundingBoxMax.x, vertex.x);
+                boundingBoxMax.y = glm::max(boundingBoxMax.y, vertex.y);
+                boundingBoxMax.z = glm::max(boundingBoxMax.z, vertex.z);
+            }
+            std::cout << "Boat Bounding Box Min: (" << boundingBoxMin.x << ", " << boundingBoxMin.y << ", " << boundingBoxMin.z << ")" << std::endl;
+            std::cout << "Boat Bounding Box Max: (" << boundingBoxMax.x << ", " << boundingBoxMax.y << ", " << boundingBoxMax.z << ")" << std::endl;
+
+        }
+    }
+
+    return ret;
+}

windows/src/Camera.cpp

@@ -0,0 +1,83 @@
+/*
+ * File:        Camera.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Camera
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "Camera.h"
+#include <GL/freeglut.h>
+#include <glm/gtc/matrix_transform.hpp>
+
+Camera::Camera() : position(10.0f, 10.0f, 10.0f), target(0.0f, 0.0f, 0.0f), up(0.0f, 1.0f, 0.0f),
+                   aspectRatio(1.0f), fov(45.0f), nearPlane(0.1f), farPlane(100.0f) {}
+
+Camera::~Camera() {}
+
+void Camera::init() {
+    // Initial camera setup if needed
+}
+
+void Camera::update(const Input& input, const glm::vec3& boatPosition) {
+    target = boatPosition;
+
+    glm::vec3 lookDirection;
+    lookDirection.x = cos(glm::radians(pitchAngle)) * cos(glm::radians(yawAngle));
+    lookDirection.y = sin(glm::radians(pitchAngle));
+    lookDirection.z = cos(glm::radians(pitchAngle)) * sin(glm::radians(yawAngle));
+    lookDirection = glm::normalize(lookDirection);
+
+    position = target - lookDirection * glm::vec3(10.0f); // **Update position here in update**
+    position.y = glm::max(position.y, 2.0f);
+
+    //position = boatPosition + glm::vec3(5.0f, 5.0f, 5.0f); // Offset from boat
+    //position.y = glm::max(position.y, 2.0f); // Keep camera above water
+
+    up = glm::vec3(0.0f, 1.0f, 0.0f);    
+
+    glm::vec3 forward = glm::normalize(target - position);
+    glm::vec3 right = glm::normalize(glm::cross(forward, up));
+    // Recalculate up to ensure orthogonality (important for gluLookAt)
+    up = glm::normalize(glm::cross(right, forward));
+
+    handleMouseInput(input, 1.0f/60.0f); // Example deltaTime (fixed 60fps for now) 
+}
+
+void Camera::lookAt() const {
+    gluLookAt(position.x, position.y, position.z,
+              target.x, target.y, target.z,
+              up.x, up.y, up.z);
+}
+
+glm::mat4 Camera::getViewMatrix() const { // Keep `const` method
+    // Recalculate camera position and up vector based on yawAngle and pitchAngle
+
+
+    // **Calculate view matrix based on CURRENT position, target, up - NO MODIFICATION of members in getViewMatrix**
+    return glm::lookAt(position, target, up); // Use current position, target, up
+}
+
+
+void Camera::handleMouseInput(const Input& input, float deltaTime) {
+    if (input.isMouseButtonDown(GLUT_RIGHT_BUTTON)) { // Rotate only when right mouse button is pressed
+        float mouseSensitivity = 0.1f; // Adjust sensitivity
+        yawAngle   += input.getMouseDeltaX() * mouseSensitivity;
+        pitchAngle -= input.getMouseDeltaY() * mouseSensitivity; // Invert vertical mouse motion
+
+        // Clamp pitch angle to prevent camera flipping
+        pitchAngle = glm::clamp(pitchAngle, -89.0f, 89.0f);
+
+    }
+}
+
+void Camera::rotateYaw(float angle) {
+    yawAngle += angle;
+}
+
+void Camera::rotatePitch(float angle) {
+    pitchAngle += angle;
+}

windows/src/Game.cpp

@@ -0,0 +1,137 @@
+/*
+ * File:        Game.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class integrates all items into the game world.
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Game.h"
+
+Game* Game::instance = nullptr;
+
+Game::Game() : renderer(), input(), ocean(200), boat(), camera(), terrain(150, 1.0f)  {
+    instance = this;
+}
+
+Game::~Game() {
+    instance = nullptr;
+}
+
+bool Game::init(int argc, char** argv) {
+    glutInit(&argc, argv);
+    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
+    glutInitWindowSize(1200, 800);
+    glutCreateWindow("3D Boat Simulation");
+
+    // **Initialize GLEW AFTER creating the window:**
+    if (glewInit() != GLEW_OK) {
+        //std::cerr << "GLEW initialization failed!" << std::endl;
+        return false;
+    }
+
+
+
+    glutDisplayFunc(displayCallback);
+    glutReshapeFunc(reshapeCallback);
+    glutKeyboardFunc(keyboardCallback);
+    glutKeyboardUpFunc(keyboardUpCallback);
+    glutSpecialFunc(specialCallback);
+    glutSpecialUpFunc(specialUpCallback);
+    glutMouseFunc(mouseCallback);
+    glutMotionFunc(motionCallback);
+    glutTimerFunc(16, timerCallback, 0); // ~60 FPS
+
+    glEnable(GL_DEPTH_TEST);
+    renderer.init();
+    //int oceanGridSize = 1000; // Default gridSize (you can change this)
+    //ocean = Ocean(oceanGridSize); // Pass gridSize to constructor
+    ocean.init();
+
+    if (!boat.init("assets/models/boat.obj", "assets/models/boat.jpg")) {
+        std::cerr << "Boat initialization failed!" << std::endl;
+        return false;
+    }
+    boat.setScale(0.01f); // Example: Make the boat half its original size
+
+
+
+
+    std::cerr << "Terrain init" << std::endl;
+
+    // Initialize Terrain
+    if (!terrain.init(renderer.heightMapTextureID)) {
+        std::cerr << "Terrain initialization failed!" << std::endl;
+        return false;
+    }
+    std::cerr << "Camera init" << std::endl;
+
+    camera.init();
+    std::cerr << "Input init" << std::endl;
+
+    input.init();
+    return true;
+}
+
+void Game::run() {
+    glutMainLoop();
+}
+
+void Game::cleanup() {
+    renderer.cleanup();
+    ocean.cleanup();
+    boat.cleanup();
+    terrain.cleanup(); // Cleanup terrain
+
+}
+
+void Game::displayCallback() {
+    instance->renderer.renderScene(instance->ocean, instance->boat, instance->camera, instance->terrain); // **Pass instance->terrain**
+        glutSwapBuffers();
+}
+
+void Game::reshapeCallback(int width, int height) {
+    instance->renderer.reshape(width, height);
+    instance->camera.setAspectRatio(static_cast<float>(width) / height);
+}
+
+void Game::keyboardCallback(unsigned char key, int x, int y) {
+    instance->input.handleKeyPress(key);
+}
+
+void Game::keyboardUpCallback(unsigned char key, int x, int y) {
+    instance->input.handleKeyRelease(key);
+}
+
+void Game::specialCallback(int key, int x, int y) {
+    instance->input.handleSpecialKeyPress(key);
+}
+
+void Game::specialUpCallback(int key, int x, int y) {
+    instance->input.handleSpecialKeyRelease(key);
+}
+
+void Game::mouseCallback(int button, int state, int x, int y) {
+    instance->input.handleMouseClick(button, state, x, y);
+}
+
+void Game::motionCallback(int x, int y) {
+    instance->input.handleMouseMove(x, y);
+}
+
+void Game::updateGame() {
+    float deltaTime = 1.0f / 60.0f; // Fixed timestep for simplicity
+    instance->input.update();
+    instance->boat.update(instance->input, instance->ocean, deltaTime);
+    instance->camera.update(instance->input, instance->boat.getPosition()); // Camera follows boat (optional)
+    instance->ocean.update(deltaTime);
+}
+
+void Game::timerCallback(int value) {
+    instance->updateGame();
+    glutTimerFunc(16, timerCallback, 0); // Re-register timer
+    glutPostRedisplay(); // Request redraw
+}
+

windows/src/Input.cpp

@@ -0,0 +1,65 @@
+/*
+ * File:        Input.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class defines the game inputs.
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "Input.h"
+#include <GL/freeglut.h>
+#include <cstring>
+Input::Input() {
+    memset(mouseButtonsDown, false, sizeof(mouseButtonsDown)); // Initialize mouse button states to false
+    mouseX = mouseY = lastMouseX = lastMouseY = 0;
+    mouseDeltaX = mouseDeltaY = 0;
+}
+Input::~Input() {}
+
+void Input::init() {}
+void Input::update() {
+    // Calculate mouse delta
+    mouseDeltaX = mouseX - lastMouseX;
+    mouseDeltaY = mouseY - lastMouseY;
+
+    // Update last mouse positions for next frame
+    lastMouseX = mouseX;
+    lastMouseY = mouseY;
+}
+void Input::handleKeyPress(unsigned char key) {
+    keysDown.insert(key);
+}
+
+void Input::handleKeyRelease(unsigned char key) {
+    keysDown.erase(key);
+}
+
+void Input::handleSpecialKeyPress(int key) {
+    specialKeysDown.insert(key);
+}
+
+void Input::handleSpecialKeyRelease(int key) {
+    specialKeysDown.erase(key);
+}
+
+void Input::handleMouseClick(int button, int state, int x, int y) {
+    if (button >= 0 && button < 5) { // Check button index is within range
+        mouseButtonsDown[button] = (state == GLUT_DOWN);
+    }
+}
+
+void Input::handleMouseMove(int x, int y) {
+    mouseX = x;
+    mouseY = y;
+}
+
+bool Input::isKeyDown(unsigned char key) const {
+    return keysDown.count(key);
+}
+
+bool Input::isSpecialKeyDown(int key) const {
+    return specialKeysDown.count(key);
+}

windows/src/Ocean.cpp

@@ -0,0 +1,403 @@
+/*
+ * File:        Ocean.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class defines ocean (surface). The core functions of this class are optimized by the IPA Project 2025.
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Ocean.h"
+#include <cmath>
+#include <glm/gtc/constants.hpp> // For pi
+#include <chrono>
+
+
+
+#if ASM_TYPE==CLEAR_ASM
+    // Assembly version declaration (signature changed to float arrays)
+    extern "C" void updateVertices_simd(float* updatedVertices_array, float* updatedNormals_array, size_t numVertices, float time);
+
+#else
+
+    // C++ implementation of SIMD version (now also taking float arrays for consistency)
+    void Ocean::updateVertices_simd(float* updatedVertices_array, float* updatedNormals_array, size_t numVertices, float time)
+    {
+        // Placeholder C++ implementation using float arrays
+        //for (size_t i = 0; i < numVertices; ++i) {
+        //    updatedVertices_array[i * 3 + 0] += time * 0.1f; // Example: simple movement in x-direction (modifying float array directly)
+        //}
+        // Update normals in the float array as needed based on your simulation
+    }
+#endif
+
+Ocean::Ocean(int gridSize) : time(0.0f),gridSize(gridSize), gridSpacing(1.0f), 
+                             amplitude(0.8f), wavelength(10.0f), frequency(1.0f), // Adjusted amplitude slightly
+                             direction(glm::vec2(1.0f, 0.0f)), phase(0.0f)
+{
+    gerstnerWaves.push_back({1.0f, 10.0f, 1.0f, glm::normalize(glm::vec2(1.0f, 0.0f)), 0.0f});
+    gerstnerWaves.push_back({0.3f, 5.0f, 2.0f, glm::normalize(glm::vec2(1.0f, 1.0f)), 0.0f});
+    //gerstnerWaves.push_back({1.0f, 3.0f, 1.0f, glm::normalize(glm::vec2(1.0f, 0.5f)), 0.0f});
+    //gerstnerWaves.push_back({0.3f, 5.0f, 2.0f, glm::normalize(glm::vec2(0.5f, 0.5f)), 0.0f});
+    //gerstnerWaves.push_back({1.0f, 10.0f, 1.0f, glm::normalize(glm::vec2(1.0f, 0.0f)), 0.0f});
+    //gerstnerWaves.push_back({0.5f, 2.0f, 3.0f, glm::normalize(glm::vec2(1.0f, 1.0f)), 0.0f});
+    //gerstnerWaves.push_back({1.0f, 1.0f, 0.2f, glm::normalize(glm::vec2(0.7f, 0.2f)), 0.0f});
+    //gerstnerWaves.push_back({0.5f, 1.2f, 2.0f, glm::normalize(glm::vec2(0.9f, 0.8f)), 0.0f});
+}
+
+Ocean::~Ocean()
+{
+    cleanup(); // Call cleanup to release OpenGL resources
+}
+
+bool Ocean::init()
+{
+    generateGrid();
+    createBuffers(); // Create VBOs and IBO
+
+    return true;
+}
+
+void Ocean::cleanup()
+{
+    // No dynamic memory allocation in this simple version
+    // Release OpenGL resources (VBOs, IBO, VAO)
+    glDeleteBuffers(1, &vertexBufferID);
+    glDeleteBuffers(1, &normalBufferID);
+    glDeleteBuffers(1, &texCoordBufferID);
+    glDeleteBuffers(1, &indexBufferID);
+    glDeleteVertexArrays(1, &vaoID);
+    vertexBufferID = 0;
+    normalBufferID = 0;
+    texCoordBufferID = 0;
+    indexBufferID = 0;
+    vaoID = 0;
+}
+
+void add_sse(float* a, float* b, float* result) {
+    __m128 vec1 = _mm_loadu_ps(a);   // Load 4 floats from a
+    __m128 vec2 = _mm_loadu_ps(b);   // Load 4 floats from b
+    __m128 sum = _mm_add_ps(vec1, vec2); // Perform vector addition
+    _mm_storeu_ps(result, sum);      // Store result
+}
+
+
+void Ocean::update(float deltaTime)
+{
+    time += deltaTime;
+    std::vector<glm::vec3> updatedVertices_vec = vertices; // Create a copy to update (vector version)
+    std::vector<glm::vec3> updatedNormals_vec(vertices.size()); // Vector to store updated normals (vector version)
+
+    std::vector<glm::vec3> updatedVertices_simd_vec = vertices; // Create a copy to update (vector for comparison)
+    std::vector<glm::vec3> updatedNormals_simd_vec(vertices.size()); // Vector to store updated normals (vector for comparison)
+
+
+    // --- Conversion to Float Arrays for SIMD function ---
+    size_t numVertices = vertices.size();
+    size_t floatArraySize = numVertices * 3;
+
+    float* updatedVertices_array = new float[floatArraySize];
+    float* updatedNormals_array = new float[floatArraySize];
+    float* updatedVertices_simd_array = new float[floatArraySize]; // Array for SIMD function
+    float* updatedNormals_simd_array = new float[floatArraySize]; // Array for SIMD function
+
+
+    // Convert vector of vec3 to float array (for both normal and simd versions)
+    for (size_t i = 0; i < numVertices; ++i) {
+        updatedVertices_array[i * 3 + 0] = updatedVertices_vec[i].x;
+        updatedVertices_array[i * 3 + 1] = updatedVertices_vec[i].y;
+        updatedVertices_array[i * 3 + 2] = updatedVertices_vec[i].z;
+
+        updatedNormals_array[i * 3 + 0] = updatedNormals_vec[i].x; // Normals init - adjust as needed
+        updatedNormals_array[i * 3 + 1] = updatedNormals_vec[i].y;
+        updatedNormals_array[i * 3 + 2] = updatedNormals_vec[i].z;
+
+        updatedVertices_simd_array[i * 3 + 0] = updatedVertices_simd_vec[i].x; // SIMD version init
+        updatedVertices_simd_array[i * 3 + 1] = updatedVertices_simd_vec[i].y;
+        updatedVertices_simd_array[i * 3 + 2] = updatedVertices_simd_vec[i].z;
+
+        updatedNormals_simd_array[i * 3 + 0] = updatedNormals_simd_vec[i].x; // SIMD normals init
+        updatedNormals_simd_array[i * 3 + 1] = updatedNormals_simd_vec[i].y;
+        updatedNormals_simd_array[i * 3 + 2] = updatedNormals_simd_vec[i].z;
+
+    }
+    auto start_time = std::chrono::high_resolution_clock::now();
+    uint64_t start = rdtsc();
+    // --- Call C++ version for comparison (using vector) ---
+    updateVertices(&updatedVertices_vec, &updatedNormals_vec, time);
+
+    uint64_t end = rdtsc();
+
+    auto end_time = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+
+    std::cout << "Ocean::update took " << duration.count() << "ns " <<  "CPU cycles: " << (end - start) << std::endl;
+
+
+    start_time = std::chrono::high_resolution_clock::now();
+    start = rdtsc();
+
+    // --- Call SIMD version (now taking float arrays) ---
+    updateVertices_simd(updatedVertices_simd_array, updatedNormals_simd_array, numVertices, time);
+    end = rdtsc();
+
+    end_time = std::chrono::high_resolution_clock::now();
+    duration = std::chrono::duration_cast<std::chrono::nanoseconds>(end_time - start_time);
+
+    std::cout << "Ocean::update (SIMD) took " << duration.count() << "ns " <<  "CPU cycles: " << (end - start) << std::endl;
+
+
+    // --- Convert float arrays back to vectors for updateBuffers (if needed) ---
+    std::vector<glm::vec3> updatedVertices_vec_from_array(numVertices);
+    std::vector<glm::vec3> updatedNormals_vec_from_array(numVertices);
+
+    for (size_t i = 0; i < numVertices; ++i) {
+        updatedVertices_vec_from_array[i].x = updatedVertices_simd_array[i * 3 + 0];
+        updatedVertices_vec_from_array[i].y = updatedVertices_simd_array[i * 3 + 1];
+        updatedVertices_vec_from_array[i].z = updatedVertices_simd_array[i * 3 + 2];
+
+        updatedNormals_vec_from_array[i].x = updatedNormals_simd_array[i * 3 + 0];
+        updatedNormals_vec_from_array[i].y = updatedNormals_simd_array[i * 3 + 1];
+        updatedNormals_vec_from_array[i].z = updatedNormals_simd_array[i * 3 + 2];
+    }
+
+
+    updateBuffers(updatedVertices_vec_from_array, updatedNormals_vec_from_array); // Use vectors for updateBuffers
+
+
+    // --- Deallocate float arrays ---
+
+}
+
+
+
+void Ocean::generateGrid()
+{
+    //std::cout << "Ocean::generateGrid - gridSize: " << gridSize << " " << vertices.size()<< std::endl;
+    vertices.resize(gridSize * gridSize);
+    // Resize original coordinate vectors
+    originalWorldX.resize(gridSize * gridSize);
+    originalWorldZ.resize(gridSize * gridSize);
+
+    for (int x = 0; x < gridSize; ++x) {
+        for (int z = 0; z < gridSize; ++z) {
+            float worldX = (x - gridSize / 2.0f) * gridSpacing;
+            float worldZ = (z - gridSize / 2.0f) * gridSpacing;
+            vertices[x * gridSize + z] = glm::vec3(worldX, 0.0f, worldZ);
+
+            // Store original world coordinates
+            originalWorldX[x * gridSize + z] = worldX;
+            originalWorldZ[x * gridSize + z] = worldZ;
+        }
+    }
+}
+
+void Ocean::createBuffers()
+{
+    glGenVertexArrays(1, &vaoID);
+    checkGLError("glGenVertexArrays"); // Check after glGenVertexArrays
+    glBindVertexArray(vaoID);
+    checkGLError("glBindVertexArray"); // Check after glBindVertexArray
+
+    // Generate VBOs
+    glGenBuffers(1, &vertexBufferID);
+    checkGLError("glGenBuffers - vertexBufferID"); // Check after glGenBuffers
+    glGenBuffers(1, &normalBufferID);
+    checkGLError("glGenBuffers - normalBufferID"); // Check after glGenBuffers
+    glGenBuffers(1, &texCoordBufferID);
+    checkGLError("glGenBuffers - texCoordBufferID"); // Check after glGenBuffers
+    glGenBuffers(1, &indexBufferID);
+    checkGLError("glGenBuffers - indexBufferID"); // Check after glGenBuffers
+
+    // 1. Vertex Positions VBO
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
+    checkGLError("glBindBuffer - vertexBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_DYNAMIC_DRAW);
+    checkGLError("glBufferData - vertexBufferID"); // Check after glBufferData
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
+    checkGLError("glVertexAttribPointer - vertexBufferID"); // Check after glVertexAttribPointer
+    glEnableVertexAttribArray(0);
+    checkGLError("glEnableVertexAttribArray - location 0"); // Check after glEnableVertexAttribArray
+
+    // 2. Vertex Normals VBO (initially flat normals - updated in updateVertices/updateBuffers)
+    std::vector<glm::vec3> normals(vertices.size(), glm::vec3(0.0f, 1.0f, 0.0f)); // Initialize with flat normals
+    glBindBuffer(GL_ARRAY_BUFFER, normalBufferID);
+    checkGLError("glBindBuffer - normalBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), normals.data(), GL_DYNAMIC_DRAW);
+    checkGLError("glBufferData - normalBufferID"); // Check after glBufferData
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
+    checkGLError("glVertexAttribPointer - normalBufferID"); // Check after glVertexAttribPointer
+    glEnableVertexAttribArray(1);
+    checkGLError("glEnableVertexAttribArray - location 1"); // Check after glEnableVertexAttribArray
+
+    // 3. Texture Coordinates VBO
+    std::vector<glm::vec2> texCoords(vertices.size());
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            float texU = static_cast<float>(x) / 70.0f;
+            float texV = static_cast<float>(z) / 70.0f;
+            texCoords[x * gridSize + z] = glm::vec2(texU, texV);
+        }
+    }
+    glBindBuffer(GL_ARRAY_BUFFER, texCoordBufferID);
+    checkGLError("glBindBuffer - texCoordBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ARRAY_BUFFER, texCoords.size() * sizeof(glm::vec2), texCoords.data(), GL_STATIC_DRAW);
+    checkGLError("glBufferData - texCoordBufferID"); // Check after glBufferData
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void *)0);
+    checkGLError("glVertexAttribPointer - texCoordBufferID"); // Check after glVertexAttribPointer
+    glEnableVertexAttribArray(2);
+    checkGLError("glEnableVertexAttribArray - location 2"); // Check after glEnableVertexAttribArray
+
+    // 4. Index Buffer Object (IBO) for Quads
+    std::vector<unsigned int> indices;
+    for (int x = 0; x < gridSize - 1; ++x)
+    {
+        for (int z = 0; z < gridSize - 1; ++z)
+        {
+            unsigned int v00 = x * gridSize + z;
+            unsigned int v10 = (x + 1) * gridSize + z;
+            unsigned int v11 = (x + 1) * gridSize + (z + 1);
+            unsigned int v01 = x * gridSize + (z + 1);
+            indices.insert(indices.end(), {v00, v10, v11, v01}); // Quad indices (counter-clockwise)
+        }
+    }
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
+    checkGLError("glBindBuffer - indexBufferID"); // Check after glBindBuffer
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW);
+    checkGLError("glBufferData - indexBufferID"); // Check after glBufferData
+
+    glBindVertexArray(0);                                   // Unbind VAO
+    checkGLError("glBindVertexArray(0)");                   // Check after unbinding VAO
+    glBindBuffer(GL_ARRAY_BUFFER, 0);                       // Unbind VBO - Optional, VAO unbinding often unbinds VBOs
+    checkGLError("glBindBuffer(0) - ARRAY_BUFFER");         // Check after unbinding ARRAY_BUFFER
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);               // Unbind IBO - Optional, VAO unbinding often unbinds IBO
+    checkGLError("glBindBuffer(0) - ELEMENT_ARRAY_BUFFER"); // Check after unbinding ELEMENT_ARRAY_BUFFER
+    indexCount = indices.size();                            // Store index count for rendering
+}
+
+void Ocean::updateVertices(std::vector<glm::vec3> * updatedVertices, std::vector<glm::vec3> * updatedNormals, float time)
+{
+
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+
+            glm::vec3 &vertex = vertices[x * gridSize + z];
+            float originalX = originalWorldX[x * gridSize + z];
+            float originalZ = originalWorldZ[x * gridSize + z];
+            vertex.y = getWaveHeight(vertex.x, vertex.z, time);
+
+            (*updatedNormals)[x * gridSize + z] = getWaveNormal(originalX, originalZ, time); // Calculate normal using original coords
+        }
+    }
+    //vertices = updatedVertices; // Assign the updated vertices back
+    //updateBuffers(updatedVertices, updatedNormals);
+}
+
+void Ocean::updateBuffers(const std::vector<glm::vec3> &updatedVertices, const std::vector<glm::vec3> &updatedNormals)
+{
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, updatedVertices.size() * sizeof(glm::vec3), updatedVertices.data()); // Update vertex positions
+
+    glBindBuffer(GL_ARRAY_BUFFER, normalBufferID);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, updatedNormals.size() * sizeof(glm::vec3), updatedNormals.data()); // Update normals
+}
+
+glm::vec3 Ocean::getVertex(int x, int z) const
+{
+    return vertices[x * gridSize + z];
+}
+
+float Ocean::getWaveHeight(float x, float z, float time) const {
+    float totalHeight = 0.0f;
+    for (const auto& wave : gerstnerWaves) {
+        totalHeight += getGerstnerWaveHeight(wave, x, z, time);
+    }
+    return totalHeight;
+}
+
+float Ocean::getGerstnerWaveHeight(const GerstnerWave& wave, float x, float z, float time) const {
+    float k = 2.0f * glm::pi<float>() / wave.wavelength;
+    float w = wave.speed * k;
+    float dotProduct = glm::dot(wave.direction, glm::vec2(x, z));
+    float periodicAmplitude = wave.amplitude * 0.5f * (1.0f + sin(2.0f * glm::pi<float>() * time / wave.wavelength));
+    float waveHeightValue = periodicAmplitude * sin(k * dotProduct - w * time + wave.phase);
+
+    if (fabs(x) < 0.5f && fabs(z) < 0.5f) {
+        //std::cout << "  getGerstnerWaveHeight - time: " << time << ", periodicAmplitude: " << periodicAmplitude << ", waveHeightValue: " << waveHeightValue << std::endl;
+    }
+
+    return waveHeightValue;
+}
+
+glm::vec3 Ocean::getGerstnerWaveDisplacement(const GerstnerWave& wave, float x, float z, float time) const {
+    float k = 2.0f * glm::pi<float>() / wave.wavelength;
+    float w = wave.speed * k;
+    float dotProduct = glm::dot(wave.direction, glm::vec2(x, z));
+    float cosTerm = cos(k * dotProduct - w * time + wave.phase);
+    float periodicAmplitude = wave.amplitude * 0.5f * (1.0f + sin(2.0f * glm::pi<float>() * time / wave.wavelength));
+    return glm::vec3(wave.direction.x * periodicAmplitude * cosTerm,
+                     0.0f,
+                     wave.direction.y * periodicAmplitude * cosTerm);
+}
+
+glm::vec3 Ocean::getWaveNormal(float x, float z, float time) const {
+    glm::vec3 tangentX = glm::vec3(1.0f, 0.0f, 0.0f);
+    glm::vec3 tangentZ = glm::vec3(0.0f, 0.0f, 1.0f);
+
+    for (const auto& wave : gerstnerWaves) {
+        float k = 2.0f * glm::pi<float>() / wave.wavelength;
+        float w = wave.speed * k;
+        float dotProduct = glm::dot(wave.direction, glm::vec2(x, z));
+        float sinTerm = sin(k * dotProduct - w * time + wave.phase);
+        float cosTerm = cos(k * dotProduct - w * time + wave.phase);
+        float periodicAmplitude = wave.amplitude * 0.5f * (1.0f + sin(2.0f * glm::pi<float>() * time /  wave.wavelength));
+        float modulatedAmplitude = periodicAmplitude;
+
+        // Calculate tangent vectors for EACH wave component and ACCUMULATE them directly
+        tangentX += glm::vec3(
+            -modulatedAmplitude * wave.direction.x * wave.direction.x * k * sinTerm, // dx_dx
+             modulatedAmplitude * wave.direction.x * k * cosTerm,                 // dy_dx
+            -modulatedAmplitude * wave.direction.x * wave.direction.y * k * sinTerm  // dz_dx
+        );
+
+        tangentZ += glm::vec3(
+            -modulatedAmplitude * wave.direction.x * wave.direction.y * k * sinTerm, // dx_dz
+             modulatedAmplitude * wave.direction.y * k * cosTerm,                 // dy_dz
+            -modulatedAmplitude * wave.direction.y * wave.direction.y * k * sinTerm  // dz_dz
+        );
+    }
+
+    return glm::normalize(glm::cross(tangentZ, tangentX));
+}
+void Ocean::setGridSize(int newGridSize)
+{
+    gridSize = newGridSize;
+    generateGrid();   // Re-generate the grid with the new size
+
+    std::vector<glm::vec3> updatedVertices = vertices; // Create a copy to update
+    std::vector<glm::vec3> updatedNormals(vertices.size()); // Vector to store updated normals
+
+    updateVertices(&updatedVertices, &updatedNormals, time);
+
+    updateBuffers(updatedVertices, updatedNormals); 
+    //updateVertices(); // Re-update vertices based on waves (optional, if needed immediately)
+}
+
+GLuint Ocean::getVAO() const
+{
+    return vaoID;
+}
+
+GLuint Ocean::getIndexCount() const
+{
+    return indexCount;
+}
+
+int Ocean::getGridIndex(int x, int z) const {
+    return x * gridSize + z;
+}

windows/src/Shader.cpp

@@ -0,0 +1,126 @@
+/*
+ * File:        Shader.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Shader controll
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Shader.h"
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <vector>
+
+Shader::Shader() : vertexShaderID(0), fragmentShaderID(0), programID(0) {}
+
+Shader::~Shader() {
+    cleanup();
+}
+
+
+bool Shader::loadShader(const char* vertexShaderPath, const char* fragmentShaderPath) {
+    // 1. Compile vertex and fragment shaders
+    if (!compileShader(vertexShaderID, GL_VERTEX_SHADER, vertexShaderPath)) return false;
+    if (!compileShader(fragmentShaderID, GL_FRAGMENT_SHADER, fragmentShaderPath)) return false;
+
+    // 2. Link shader program
+    if (!linkShaderProgram()) return false;
+
+    return true; // Shader program loaded and linked successfully
+}
+
+
+bool Shader::compileShader(GLuint& shaderID, GLenum shaderType, const char* shaderPath) {
+    shaderID = glCreateShader(shaderType);
+    std::string shaderCode;
+    std::ifstream shaderFile;
+    shaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit); // Enable exception throwing
+    try {
+        shaderFile.open(shaderPath);
+        std::stringstream shaderStream;
+        shaderStream << shaderFile.rdbuf();
+        shaderFile.close();
+        shaderCode = shaderStream.str();
+    } catch (std::ifstream::failure& e) {
+        std::cerr << "ERROR::SHADER::FILE_NOT_SUCCESSFULLY_READ: " << shaderPath << std::endl;
+        return false;
+    }
+    const char* shaderCodeCStr = shaderCode.c_str();
+    glShaderSource(shaderID, 1, &shaderCodeCStr, NULL);
+    glCompileShader(shaderID);
+
+    // Check for shader compile errors
+    int success;
+    char infoLog[512];
+    glGetShaderiv(shaderID, GL_COMPILE_STATUS, &success);
+    if (!success) {
+        glGetShaderInfoLog(shaderID, 512, NULL, infoLog);
+        std::cerr << "ERROR::SHADER::COMPILATION_FAILED: " << shaderPath << "\n" << infoLog << std::endl;
+        return false;
+    }
+    return true;
+}
+
+
+bool Shader::linkShaderProgram() {
+    programID = glCreateProgram();
+    glAttachShader(programID, vertexShaderID);
+    glAttachShader(programID, fragmentShaderID);
+    glLinkProgram(programID);
+
+    // Check for linking errors
+    int success;
+    char infoLog[512];
+    glGetProgramiv(programID, GL_LINK_STATUS, &success);
+    if (!success) {
+        glGetProgramInfoLog(programID, 512, NULL, infoLog);
+        std::cerr << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl;
+        return false;
+    }
+
+    glDeleteShader(vertexShaderID);   // Delete shaders as they are linked into program now and no longer necessary
+    glDeleteShader(fragmentShaderID); // Shader objects are deleted after linking
+    vertexShaderID = 0;
+    fragmentShaderID = 0;
+
+    return true;
+}
+
+
+void Shader::use() {
+    glUseProgram(programID);
+}
+
+void Shader::unuse() {
+    glUseProgram(0); // Unuse shader program (use fixed-function pipeline)
+}
+
+void Shader::cleanup() {
+    if (programID != 0) {
+        glDeleteProgram(programID);
+        programID = 0;
+    }
+}
+
+
+void Shader::setInt(const std::string& name, int value) const {
+    glUniform1i(glGetUniformLocation(programID, name.c_str()), value);
+}
+
+void Shader::setFloat(const std::string& name, float value) const {
+    glUniform1f(glGetUniformLocation(programID, name.c_str()), value);
+}
+
+void Shader::setVec3(const std::string& name, const glm::vec3& value) const {
+    glUniform3fv(glGetUniformLocation(programID, name.c_str()), 1, glm::value_ptr(value));
+}
+
+void Shader::setMat4(const std::string& name, const glm::mat4& mat) const {
+    glUniformMatrix4fv(glGetUniformLocation(programID, name.c_str()), 1, GL_FALSE, glm::value_ptr(mat));
+}
+void Shader::setMat3(const std::string& name, const glm::mat3& mat) const {
+     glUniformMatrix3fv(glGetUniformLocation(programID, name.c_str()), 1, GL_FALSE, glm::value_ptr(mat));
+}

windows/src/Terrain.cpp

@@ -0,0 +1,195 @@
+/*
+ * File:        Terran.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: This class defines terrain (surface).
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "Terrain.h"
+#include <cmath>
+#include <glm/gtc/constants.hpp>
+#include <iostream>
+#include "utils.h" // Include utils.h for checkGLError
+#include <GL/glew.h>
+
+Terrain::Terrain(int gridSize, float gridSpacing)
+    : gridSize(gridSize),
+      gridSpacing(gridSpacing),
+      vertices(gridSize * gridSize),
+      normals(gridSize * gridSize),
+      texCoords(gridSize * gridSize),
+      vertexBufferID(0),
+      normalBufferID(0),
+      texCoordBufferID(0),
+      indexBufferID(0),
+      vaoID(0),
+      indexCount(0) {}
+
+Terrain::~Terrain() {
+    cleanup();
+}
+
+bool Terrain::init(GLuint heightMapTextureID) {
+    generateGrid(heightMapTextureID);
+    createBuffers();
+    return true;
+}
+
+void Terrain::cleanup() {
+    glDeleteBuffers(1, &vertexBufferID);
+    glDeleteBuffers(1, &normalBufferID);
+    glDeleteBuffers(1, &texCoordBufferID);
+    glDeleteBuffers(1, &indexBufferID);
+    glDeleteVertexArrays(1, &vaoID);
+}
+
+
+
+void Terrain::generateGrid(GLuint heightMapTextureID) {
+
+    std::cout << "Terrain::generateGrid - gridSize: " << gridSize << std::endl;
+    vertices.resize(gridSize * gridSize);
+    normals.resize(gridSize * gridSize);
+    texCoords.resize(gridSize * gridSize);
+
+    // **Access Heightmap Texture Data**
+    glBindTexture(GL_TEXTURE_2D, heightMapTextureID); // Bind heightmap texture
+    GLint textureWidth, textureHeight;
+    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_WIDTH, &textureWidth); // Get texture width
+    glGetTexLevelParameteriv(GL_TEXTURE_2D, 0, GL_TEXTURE_HEIGHT, &textureHeight); // Get texture height
+
+    std::vector<unsigned char> heightmapData(textureWidth * textureHeight); // Assuming 8-bit grayscale heightmap
+    glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+    glGetTexImage(GL_TEXTURE_2D, 0, GL_RED, GL_UNSIGNED_BYTE, heightmapData.data()); // Get texture pixel data (Red channel = grayscale height)
+    glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture
+
+    float heightScale = 40.0f; // Adjust this to control terrain height scale
+
+    for (int x = 0; x < gridSize; ++x) {
+        for (int z = 0; z < gridSize; ++z) {
+            float worldX = (x - gridSize / 2.0f) * gridSpacing;
+            float worldZ = (z - gridSize / 2.0f) * gridSpacing;
+
+            // **Sample height from heightmap texture**
+            float height = 0.0f;
+            if (x < textureWidth && z < textureHeight && x >= 0 && z >= 0) { // Bounds check - important!
+                height = static_cast<float>(heightmapData[z * textureWidth + x]) / 255.0f * heightScale-15.0; // Normalize to [0, 1], scale by heightScale
+
+            } else {
+                // Handle out-of-bounds access (e.g., set height to 0 or a default value)
+                height = 0.0f;
+            }
+
+            //vertices[x * gridSize + z] = glm::vec3(worldX, height, worldZ); // Set vertex position with height from heightmap
+            vertices[x * gridSize + z] = glm::vec3(worldX, height, worldZ); // Flat terrain at y=0
+            normals[x * gridSize + z] = glm::vec3(0.0f, 1.0f, 0.0f);    // Upward normals for flat terrain
+            texCoords[x * gridSize + z] = glm::vec2(static_cast<float>(x) / 50.0f, static_cast<float>(z) / 50.0f); // Example texture tiling
+            //originalWorldX[x * gridSize + z] = worldX;
+            //originalWorldZ[x * gridSize + z] = worldZ;
+        }
+    }
+    std::cout << "Width: " << textureWidth << "Geight: " << textureHeight << std::endl;
+}
+
+
+void Terrain::createBuffers() {
+    glGenVertexArrays(1, &vaoID);
+    checkGLError("1"); // Check after drawMeshVBO call
+
+    glBindVertexArray(vaoID);
+    checkGLError("2"); // Check after drawMeshVBO call
+
+    glGenBuffers(1, &vertexBufferID);
+    checkGLError("3"); // Check after drawMeshVBO call
+
+    glBindBuffer(GL_ARRAY_BUFFER, vertexBufferID);
+    checkGLError("4"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW);
+    checkGLError("5"); // Check after drawMeshVBO call
+
+    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
+    checkGLError("6"); // Check after drawMeshVBO call
+
+    glEnableVertexAttribArray(0);
+    checkGLError("7"); // Check after drawMeshVBO call
+
+    glGenBuffers(1, &normalBufferID);
+    checkGLError("8"); // Check after drawMeshVBO call
+
+    glBindBuffer(GL_ARRAY_BUFFER, normalBufferID);
+    checkGLError("9"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), normals.data(), GL_STATIC_DRAW);
+    checkGLError("10"); // Check after drawMeshVBO call
+
+    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
+    checkGLError("11"); // Check after drawMeshVBO call
+
+    glEnableVertexAttribArray(1);
+    checkGLError("12"); // Check after drawMeshVBO call
+
+
+    glGenBuffers(1, &texCoordBufferID);
+    checkGLError("13"); // Check after drawMeshVBO call
+
+    glBindBuffer(GL_ARRAY_BUFFER, texCoordBufferID);
+    checkGLError("14"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ARRAY_BUFFER, texCoords.size() * sizeof(glm::vec2), texCoords.data(), GL_STATIC_DRAW);
+    checkGLError("15"); // Check after drawMeshVBO call
+
+    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0);
+    checkGLError("16"); // Check after drawMeshVBO call
+
+    glEnableVertexAttribArray(2);
+    checkGLError("17"); // Check after drawMeshVBO call
+
+
+    std::vector<unsigned int> indices;
+    for (int x = 0; x < gridSize - 1; ++x) {
+        for (int z = 0; z < gridSize - 1; ++z) {
+            unsigned int v00 = x * gridSize + z;
+            unsigned int v10 = (x + 1) * gridSize + z;
+            unsigned int v11 = (x + 1) * gridSize + (z + 1);
+            unsigned int v01 = x * gridSize + (z + 1);
+            indices.insert(indices.end(), {v00, v10, v11, v01});
+        }
+    }
+    glGenBuffers(1, &indexBufferID);
+    checkGLError("glGenBuffers - indexBufferID"); // Check after glGenBuffers
+    
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indexBufferID);
+    checkGLError("18"); // Check after drawMeshVBO call
+
+    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indices.size() * sizeof(unsigned int), indices.data(), GL_STATIC_DRAW);
+    checkGLError("19"); // Check after drawMeshVBO call
+
+    glBindVertexArray(0);
+    checkGLError("20"); // Check after drawMeshVBO call
+
+    indexCount = indices.size();
+}
+
+void Terrain::updateBuffers() {
+    // Not needed for static terrain in this basic example
+}
+
+
+glm::vec3 Terrain::getVertex(int x, int z) const {
+    assert(x >= 0 && x < gridSize);
+    assert(z >= 0 && z < gridSize);
+    return vertices[x * gridSize + z];
+}
+
+
+glm::vec3 Terrain::getNormal(float x, float z) const
+{
+    return normals[x * gridSize + z];
+
+}

windows/src/main.cpp

@@ -0,0 +1,21 @@
+/*
+ * File:        main.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Main
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+#include "Game.h"
+
+int main(int argc, char** argv) {
+    Game game;
+    if (!game.init(argc, argv)) {
+        return 1;
+    }
+    game.run();
+    game.cleanup();
+    return 0;
+}

windows/src/render.cpp

@@ -0,0 +1,634 @@
+/*
+ * File:        render.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Game renderer
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+
+#include "Renderer.h"
+#include <iostream>
+#include <SOIL/SOIL.h>
+#include "utils.h"
+#include <glm/gtc/type_ptr.hpp>
+
+
+
+
+Renderer::Renderer() : oceanTextureID(0), boatTextureID(0), terrainTextureID(0), heightMapTextureID(0) {}
+
+Renderer::~Renderer() {}
+
+bool Renderer::init()
+{
+    glewInit();
+    if (glewIsSupported("GL_VERSION_3_0"))
+    {
+        std::cout << "OpenGL 3.0 or higher supported: Shaders will work." << std::endl;
+    }
+    else
+    {
+        std::cout << "OpenGL 3.0 or higher NOT supported: Shaders might not work." << std::endl;
+    }
+
+    glClearColor(0.529f, 0.808f, 0.922f, 1.0f); // Light blue background
+
+    if (!loadTexture("assets/textures/ocean_texture.png", oceanTextureID))
+    {
+        std::cerr << "Error loading ocean texture." << std::endl;
+        return false;
+    }
+    if (!loadTexture("assets/textures/rock_texture.png", terrainTextureID)) { // Assuming you name it terrain_texture.jpg
+        std::cerr << "Error loading terrain texture." << std::endl;
+        return false;
+    }
+    checkGLError("loadTexture - terrainTexture"); // Check after terrain texture loading
+
+    // **Load heightmap texture:**
+    if (!loadTexture("assets/textures/terain.png", heightMapTextureID)) { // Assuming heightmap is terrain_heightmap.png
+        std::cerr << "Error loading terrain heightmap texture." << std::endl;
+        return false;
+    }
+    checkGLError("loadTexture - heightMapTexture"); // Check after heightmap texture loading
+
+    terrainShader.loadShader("assets/shaders/terrain_vertex_shader.glsl", "assets/shaders/terrain_fragment_shader.glsl");
+    if (!terrainShader.isLoaded()) {
+        std::cerr << "Error loading terrain shader program!" << std::endl;
+        return false;
+    }
+    checkGLError("terrainShader.loadShader"); // Check after shader loading
+    // Load and compile ocean shader program:
+    oceanShader.loadShader("assets/shaders/ocean_vertex_shader.glsl", "assets/shaders/ocean_fragment_shader.glsl");
+    if (!oceanShader.isLoaded()) {
+        std::cerr << "Error loading ocean shader program!" << std::endl;
+        return false;
+    }
+    checkGLError("oceanShader.loadShader"); // Check after shader loading
+    // Boat texture is now loaded in drawBoat, based on Boat class texture path
+
+    setupLighting();
+    // shaderProgram.loadShader("assets/shaders/vertex_shader.glsl", "assets/shaders/fragment_shader.glsl"); // Optional shader loading
+
+    return true;
+}
+
+void Renderer::cleanup()
+{
+    glDeleteTextures(1, &oceanTextureID);
+    glDeleteTextures(1, &boatTextureID);
+    glDeleteTextures(1, &terrainTextureID);
+    glDeleteTextures(1, &heightMapTextureID);
+
+    // shaderProgram.cleanup(); // Optional shader cleanup
+}
+
+void Renderer::renderScene(const Ocean &ocean, const Boat &boat, const Camera &camera, const Terrain &terrain)
+{
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+    glLoadIdentity();
+
+    camera.lookAt(); // Set up camera view
+
+    setupLighting(); // Ensure lighting is enabled each frame
+    drawTerrain(terrain, camera); // **Call drawTerrain here - BEFORE drawOcean**
+
+    drawOcean(ocean, camera);
+    drawBoat(boat);
+    checkGLError("drawTerrain"); // Check after drawTerrain
+    // Optional: Render skybox, UI, etc.
+    // ...
+}
+
+void Renderer::reshape(int width, int height)
+{
+    glViewport(0, 0, width, height);
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    gluPerspective(45.0f, static_cast<float>(width) / height, 0.1f, 100.0f); // Adjust near/far planes
+    glMatrixMode(GL_MODELVIEW);
+}
+
+bool Renderer::loadTexture(const char *filename, GLuint &textureID)
+{
+    textureID = SOIL_load_OGL_texture(filename, SOIL_LOAD_AUTO, SOIL_CREATE_NEW_ID, SOIL_FLAG_INVERT_Y);
+    if (textureID == 0)
+    {
+        std::cerr << "SOIL loading error: '" << SOIL_last_result() << "' (" << filename << ")" << std::endl;
+        return false;
+    }
+
+    glBindTexture(GL_TEXTURE_2D, textureID);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+    glGenerateMipmap(GL_TEXTURE_2D); // Generate mipmaps for better quality at distance
+    glBindTexture(GL_TEXTURE_2D, 0); // Unbind texture
+    return true;
+}
+
+void Renderer::setupLighting()
+{
+    glEnable(GL_LIGHTING);
+    glEnable(GL_LIGHT0);
+
+    GLfloat lightAmbient[] = {0.2f, 0.2f, 0.2f, 1.0f};
+    GLfloat lightDiffuse[] = {0.8f, 0.8f, 0.8f, 1.0f};
+    GLfloat lightSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f};
+    GLfloat lightPosition[] = {10.0f, 10.0f, 10.0f, 0.0f}; // Directional light from above and to the right
+
+    glLightfv(GL_LIGHT0, GL_AMBIENT, lightAmbient);
+    glLightfv(GL_LIGHT0, GL_DIFFUSE, lightDiffuse);
+    glLightfv(GL_LIGHT0, GL_SPECULAR, lightSpecular);
+    glLightfv(GL_LIGHT0, GL_POSITION, lightPosition);
+
+    glEnable(GL_COLOR_MATERIAL);
+    glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); // Material colors track glColor
+    GLfloat matSpecular[] = {0.5f, 0.5f, 0.5f, 1.0f};
+    GLfloat matShininess[] = {50.0f};
+    glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular);
+    glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, matShininess);
+}
+
+void Renderer::drawOcean(const Ocean& ocean, const Camera& camera)
+{
+    
+    glPushMatrix();
+
+    // Use the ocean shader program:
+    oceanShader.use();
+    checkGLError("oceanShader.use"); // Check after shader use
+
+    // Set Uniforms for Ocean Shader:
+    glm::mat4 modelMatrix;
+    glm::mat4 projectionMatrix;
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(modelMatrix));
+    checkGLError("glGetFloatv(GL_MODELVIEW_MATRIX)"); // Check after glGetFloatv
+    glGetFloatv(GL_PROJECTION_MATRIX, glm::value_ptr(projectionMatrix));
+    checkGLError("glGetFloatv(GL_PROJECTION_MATRIX)"); // Check after glGetFloatv
+
+
+    oceanShader.setMat4("model", modelMatrix);
+    oceanShader.setMat4("view", camera.getViewMatrix());
+    oceanShader.setMat4("projection", projectionMatrix);
+    oceanShader.setMat3("normalMatrix", glm::transpose(glm::inverse(glm::mat3(modelMatrix))));
+    checkGLError("shader.setMat4/setMat3 uniforms"); // Check after setting matrix uniforms
+
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, oceanTextureID);
+    oceanShader.setInt("oceanTexture", 0);
+    checkGLError("glBindTexture - oceanTexture"); // Check after glBindTexture
+
+    //glActiveTexture(GL_TEXTURE1);
+    //glBindTexture(GL_TEXTURE_2D, normalMapTextureID);
+    //oceanShader.setInt("normalMap", 1);
+    //checkGLError("glBindTexture - normalMapTexture"); // Check after glBindTexture
+
+
+    oceanShader.setVec3("lightDir", glm::normalize(glm::vec3(1.0f, 1.0f, 1.0f)));
+    oceanShader.setVec3("lightColor", glm::vec3(1.0f, 1.0f, 1.0f));
+    oceanShader.setVec3("viewPosWorld", camera.getPosition());
+    checkGLError("shader.setVec3 uniforms"); // Check after setting vec3 uniforms
+
+
+    drawMeshVBO(ocean); // Draw using VBOs and IBO
+    checkGLError("drawMeshVBO"); // Check after drawMeshVBO call
+
+    // Unuse shader program after drawing ocean
+    oceanShader.unuse();
+    checkGLError("oceanShader.unuse"); // Check after shader unuse
+
+    //glPopMatrix();
+
+    glPushMatrix();
+    //glTranslatef(0.0f, -1.0f, 0.0f); // Lower the ocean slightly
+
+    // **Disable Texture and Lighting for Normal Visualization**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(1.0f, 0.0f, 0.0f); // Red color for normals (you can change this)
+
+    int gridSize = ocean.getGridSize();
+    float gridSpacing = ocean.getGridSpacing();
+
+    #if SHOW_NORM
+    
+
+    // **Draw Normals as Lines**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = ocean.getVertex(x, z);
+            glm::vec3 normal = ocean.getWaveNormal(v.x, v.z, ocean.time); // Get normal at vertex
+
+            // Calculate endpoint of normal line - Scale normal for visibility
+            float normalLength = 0.5f; // Adjust this value to control normal line length
+            glm::vec3 normalEndpoint = v + normal * normalLength;
+
+            // Draw line representing the normal
+            glVertex3f(v.x, v.y, v.z);                                        // Start point of normal line (vertex position)
+            glVertex3f(normalEndpoint.x, normalEndpoint.y, normalEndpoint.z); // End point of normal line (along normal direction)
+        }
+    }
+    glEnd();
+
+    #endif
+
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+
+    glPopMatrix();
+
+    glPushMatrix();
+
+    // **Disable Texture and Lighting for Wireframe Rendering**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(0.0f, 0.0f, 0.0f); // Green color for wireframe (you can change this)
+
+
+
+
+    #if SHOW_GRID
+
+    // **Change glBegin mode to GL_LINES for Wireframe**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = ocean.getVertex(x, z);
+
+            // Draw horizontal lines (along Z-axis)
+            if (x < gridSize - 1)
+            {
+                glm::vec3 v_next_x = ocean.getVertex(x + 1, z);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_x.x, v_next_x.y, v_next_x.z);
+            }
+            // Draw vertical lines (along X-axis)
+            if (z < gridSize - 1)
+            {
+                glm::vec3 v_next_z = ocean.getVertex(x, z + 1);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_z.x, v_next_z.y, v_next_z.z);
+            }
+        }
+    }
+    glEnd();
+
+    #endif
+
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+    glPopMatrix();
+
+    glPopMatrix();
+}
+
+// ... (rest of Renderer.cpp - Renderer::drawBoat, Renderer::drawMesh, etc.) ...
+
+void Renderer::drawBoat(const Boat &boat)
+{
+    glPushMatrix();
+    glm::vec3 boatPos = boat.getPosition();
+    glm::quat boatRotation = boat.getRotation();
+    float boatScale = boat.getScale(); // Get the boat's scale factor
+
+    glTranslatef(boatPos.x, boatPos.y, boatPos.z);
+    glm::mat4 rotationMatrix = glm::mat4_cast(boatRotation);
+    glMultMatrixf(glm::value_ptr(rotationMatrix));
+
+    glScalef(boatScale, boatScale, boatScale); // Uniform scaling - scale equally in all directions
+
+    // Load boat texture here, based on the texture path from the Boat class
+    if (!boat.getTexturePath().empty())
+    {
+        if (boatTextureID == 0 || boat.getTexturePath() != lastBoatTexturePath)
+        { // Check if texture needs to be loaded or reloaded
+            if (boatTextureID != 0)
+            { // If there's a previous texture, delete it
+                glDeleteTextures(1, &boatTextureID);
+                boatTextureID = 0;
+            }
+            if (!loadTexture(boat.getTexturePath().c_str(), boatTextureID))
+            {
+                std::cerr << "Error loading boat texture: " << boat.getTexturePath() << std::endl;
+            }
+            else
+            {
+                lastBoatTexturePath = boat.getTexturePath(); // Store the path of the loaded texture
+            }
+        }
+    }
+
+    glEnable(GL_TEXTURE_2D);
+    glBindTexture(GL_TEXTURE_2D, boatTextureID);
+    glColor3f(1.0f, 1.0f, 1.0f); // Texture color modulation
+
+    // Draw the loaded boat mesh
+    drawMesh(boat.getVertices(), boat.getNormals(), boat.getTexCoords(), boat.getMaterialIndices(), boat.getMaterials()); // Pass material data
+
+    glBindTexture(GL_TEXTURE_2D, 0);
+    glDisable(GL_TEXTURE_2D);
+    glPopMatrix();
+
+    glPushMatrix();
+    glm::vec3 minPoint = boat.getBoundingBoxMin(); // Get model-space min point
+    glm::vec3 maxPoint = boat.getBoundingBoxMax(); // Get model-space max point
+
+    glTranslatef(boatPos.x, boatPos.y, boatPos.z);
+    glMultMatrixf(glm::value_ptr(rotationMatrix));
+    glScalef(boatScale, boatScale, boatScale); // Uniform scaling - scale equally in all directions
+                                               // **Draw Wireframe Bounding Box:**
+    glDisable(GL_LIGHTING);                    // Disable lighting for bounding box (solid color wireframe)
+    glColor3f(1.0f, 1.0f, 0.0f);               // Yellow color for bounding box
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Set polygon mode to line (wireframe)
+
+
+    #if SHOW_BOUDING_BOX
+    glBegin(GL_QUADS); // Draw a cube using quads (wireframe)
+
+    // Front face
+    glVertex3f(minPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, maxPoint.z);
+
+    // Back face
+    glVertex3f(minPoint.x, minPoint.y, minPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, minPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, minPoint.z);
+
+    // Top face
+    glVertex3f(minPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, minPoint.z);
+
+    // Bottom face
+    glVertex3f(minPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, minPoint.y, minPoint.z);
+
+    // Right face
+    glVertex3f(maxPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(maxPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(maxPoint.x, minPoint.y, minPoint.z);
+
+    // Left face
+    glVertex3f(minPoint.x, minPoint.y, maxPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, maxPoint.z);
+    glVertex3f(minPoint.x, maxPoint.y, minPoint.z);
+    glVertex3f(minPoint.x, minPoint.y, minPoint.z);
+
+    glEnd();
+
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Restore polygon mode to fill
+    #endif
+
+    glEnable(GL_LIGHTING);    
+                     // Re-enable lighting for boat model
+    glPopMatrix();
+}
+
+
+void Renderer::drawMeshVBO(const Ocean& ocean) {
+    // 1. Bind Vertex Array Object (VAO) - if you are using VAOs. If not, bind VBOs directly.
+    glBindVertexArray(ocean.getVAO()); // Assuming Ocean class has getVAO() that returns VAO ID
+
+    // If NOT using VAOs, you would bind VBOs individually like this:
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getVertexBufferID()); // Bind vertex VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getNormalBufferID());   // Bind normal VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getTexCoordBufferID()); // Bind texCoord VBO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ocean.getIndexBufferID()); // Bind IBO
+    */
+
+
+    // 2. Draw using glDrawElements (assuming you are using indexed rendering with IBO)
+    glDrawElements(GL_QUADS, ocean.getIndexCount(), GL_UNSIGNED_INT, 0); // Draw using indices from IBO
+
+    // If drawing as triangles instead of quads, use:
+    // glDrawElements(GL_TRIANGLES, ocean.getIndexCount(), GL_UNSIGNED_INT, 0);
+
+
+    // 3. Unbind VAO (or VBOs if not using VAOs) - optional, but good practice
+    glBindVertexArray(0);
+
+    // If NOT using VAOs, unbind VBOs individually (optional):
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    */
+}
+
+void Renderer::drawMeshTerainVBO(const Terrain& terrain) {
+    // 1. Bind Vertex Array Object (VAO) - if you are using VAOs. If not, bind VBOs directly.
+    glBindVertexArray(terrain.getVAO()); // Assuming Ocean class has getVAO() that returns VAO ID
+
+    // If NOT using VAOs, you would bind VBOs individually like this:
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getVertexBufferID()); // Bind vertex VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getNormalBufferID());   // Bind normal VBO
+    glBindBuffer(GL_ARRAY_BUFFER, ocean.getTexCoordBufferID()); // Bind texCoord VBO
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ocean.getIndexBufferID()); // Bind IBO
+    */
+
+
+    // 2. Draw using glDrawElements (assuming you are using indexed rendering with IBO)
+    glDrawElements(GL_QUADS, terrain.getIndexCount(), GL_UNSIGNED_INT, 0); // Draw using indices from IBO
+
+    // If drawing as triangles instead of quads, use:
+    // glDrawElements(GL_TRIANGLES, ocean.getIndexCount(), GL_UNSIGNED_INT, 0);
+
+
+    // 3. Unbind VAO (or VBOs if not using VAOs) - optional, but good practice
+    glBindVertexArray(0);
+
+    // If NOT using VAOs, unbind VBOs individually (optional):
+    /*
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+    */
+}
+
+// Static variable to store the last loaded boat texture path
+
+void Renderer::drawMesh(const std::vector<glm::vec3> &vertices, const std::vector<glm::vec3> &normals, const std::vector<glm::vec2> &texCoords,
+                        const std::vector<int> &materialIndices, const std::vector<tinyobj::material_t> &materials)
+{
+    glBegin(GL_TRIANGLES);
+    for (size_t i = 0; i < vertices.size(); ++i)
+    {
+        int material_index = materialIndices[i];
+        if (material_index != -1 && static_cast<std::vector<tinyobj::material_t>::size_type>(material_index) < materials.size())
+        { // Check if material index is valid
+            const tinyobj::material_t &material = materials[material_index];
+            glColor3f(material.diffuse[0], material.diffuse[1], material.diffuse[2]); // Set diffuse color
+        }
+        else
+        {
+            glColor3f(1.0f, 1.0f, 1.0f); // Default white color if no valid material
+        }
+
+        glNormal3f(normals[i].x, normals[i].y, normals[i].z);
+        glTexCoord2f(texCoords[i].x, texCoords[i].y);
+        glVertex3f(vertices[i].x, vertices[i].y, vertices[i].z);
+    }
+    glEnd();
+}
+
+// Renderer.cpp - Add drawTerrain function
+void Renderer::drawTerrain(const Terrain& terrain, const Camera& camera) {
+    
+    //printf("Drawing terrain\n");
+    glPushMatrix();
+    // No translation needed for terrain in this basic example
+    glTranslatef(0.0f, 0.0f, 0.0f); // Lower the ocean slightly
+
+    // Use the terrain shader program:
+    terrainShader.use();
+    checkGLError("terrainShader.use");
+
+    glm::mat4 modelMatrix;
+    glm::mat4 projectionMatrix;
+
+    glGetFloatv(GL_MODELVIEW_MATRIX, glm::value_ptr(modelMatrix));
+    checkGLError("glGetFloatv(GL_MODELVIEW_MATRIX)"); // Check after glGetFloatv
+    glGetFloatv(GL_PROJECTION_MATRIX, glm::value_ptr(projectionMatrix));
+    checkGLError("glGetFloatv(GL_PROJECTION_MATRIX)"); // Check after glGetFloatv
+
+    terrainShader.setMat4("model", modelMatrix);
+    terrainShader.setMat4("view", camera.getViewMatrix());
+    terrainShader.setMat4("projection", projectionMatrix);
+    terrainShader.setMat3("normalMatrix", glm::transpose(glm::inverse(glm::mat3(modelMatrix))));
+    checkGLError("terrainShader setMat4/setMat3 uniforms");
+
+    glActiveTexture(GL_TEXTURE0);
+    glBindTexture(GL_TEXTURE_2D, terrainTextureID);
+    terrainShader.setInt("terrainTexture", 0);
+    checkGLError("glBindTexture - terrainTexture");
+
+    glActiveTexture(GL_TEXTURE1); // Activate texture unit 1 for heightmap
+    glBindTexture(GL_TEXTURE_2D, heightMapTextureID); // Bind heightmap texture
+    terrainShader.setInt("heightMapTexture", 1); // Set uniform sampler2D heightMapTexture to texture unit 1
+    checkGLError("glBindTexture - heightMapTexture"); // Check after binding heightmap texture
+
+    // Lighting Uniforms (reuse same light parameters as ocean for simplicity)
+    terrainShader.setVec3("lightDir", glm::normalize(glm::vec3(1.0f, -1.0f, 1.0f))); // Example light direction
+    terrainShader.setVec3("lightColor", glm::vec3(1.0f, 1.0f, 1.0f)); // White light
+    terrainShader.setVec3("viewPosWorld", camera.getPosition());
+    checkGLError("terrainShader setVec3 uniforms");
+
+
+    drawMeshTerainVBO(terrain); // Render terrain mesh using VBOs and IBO
+    checkGLError("drawMeshVBO - terrain");
+    glBindTexture(GL_TEXTURE_2D, 0); // Bind heightmap texture
+
+    terrainShader.unuse();
+    checkGLError("terrainShader.unuse");
+
+    glPopMatrix();
+
+    
+
+    glPushMatrix();
+    glTranslatef(0.0f, 0.0f, 0.0f); // Lower the ocean slightly
+
+    // **Disable Texture and Lighting for Normal Visualization**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(1.0f, 0.0f, 0.0f); // Red color for normals (you can change this)
+
+
+    #if SHOW_NORM
+
+    int gridSize = terrain.getGridSize();
+    float gridSpacing = terrain.getGridSpacing();
+
+    // **Draw Normals as Lines**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = terrain.getVertex(x, z);
+            glm::vec3 normal = terrain.getNormal(x, z); // Get normal at vertex
+
+            // Calculate endpoint of normal line - Scale normal for visibility
+            float normalLength = 0.5f; // Adjust this value to control normal line length
+            glm::vec3 normalEndpoint = v + normal * normalLength;
+
+            // Draw line representing the normal
+            glVertex3f(v.x, v.y, v.z);                                        // Start point of normal line (vertex position)
+            glVertex3f(normalEndpoint.x, normalEndpoint.y, normalEndpoint.z); // End point of normal line (along normal direction)
+        }
+    }
+    glEnd();
+
+    #endif
+
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+
+    glPopMatrix();
+
+
+
+    glPushMatrix();
+    glTranslatef(0.0f, 0.2f, 0.0f); // Lower the ocean slightly
+
+    // **Disable Texture and Lighting for Wireframe Rendering**
+    glDisable(GL_TEXTURE_2D);
+    glDisable(GL_LIGHTING);
+    glColor3f(0.0f, 0.0f, 0.0f); // Green color for wireframe (you can change this)
+
+    #if SHOW_GRID
+    // **Change glBegin mode to GL_LINES for Wireframe**
+    glBegin(GL_LINES);
+    for (int x = 0; x < gridSize; ++x)
+    {
+        for (int z = 0; z < gridSize; ++z)
+        {
+            glm::vec3 v = terrain.getVertex(x, z);
+
+            // Draw horizontal lines (along Z-axis)
+            if (x < gridSize - 1)
+            {
+                glm::vec3 v_next_x = terrain.getVertex(x + 1, z);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_x.x, v_next_x.y, v_next_x.z);
+            }
+            // Draw vertical lines (along X-axis)
+            if (z < gridSize - 1)
+            {
+                glm::vec3 v_next_z = terrain.getVertex(x, z + 1);
+                glVertex3f(v.x, v.y, v.z);
+                glVertex3f(v_next_z.x, v_next_z.y, v_next_z.z);
+            }
+        }
+    }
+    glEnd();
+
+    #endif
+    // **Re-enable Texture and Lighting (if you want to switch back to textured rendering later)**
+    // glEnable(GL_TEXTURE_2D);
+    // glEnable(GL_LIGHTING);
+
+    glPopMatrix();
+}

windows/src/utils.cpp

@@ -0,0 +1,72 @@
+/*
+ * File:        utils.cpp
+ * Author:      Tomas Goldmann
+ * Date:        2025-03-23
+ * Description: Utils - perlinNoise is does not use in this project
+ *
+ * Copyright (c) 2025, Brno University of Technology. All rights reserved.
+ * Licensed under the MIT.
+ */
+
+
+#include "utils.h"
+
+
+uint64_t rdtsc() {
+    return __rdtsc();  // Read Time-Stamp Counter
+}
+
+void checkGLError(const char* operation) {
+    GLenum error = glGetError();
+    if (error != GL_NO_ERROR) {
+        std::cerr << "OpenGL Error after " << operation << ": ";
+        switch (error) {
+            case GL_INVALID_ENUM:
+                std::cerr << "GL_INVALID_ENUM - An unacceptable value is specified for an enumerated argument.";
+                break;
+            case GL_INVALID_VALUE:
+                std::cerr << "GL_INVALID_VALUE - A numeric argument is out of range.";
+                break;
+            case GL_INVALID_OPERATION:
+                std::cerr << "GL_INVALID_OPERATION - The specified operation is not allowed in the current state.";
+                break;
+            case GL_INVALID_FRAMEBUFFER_OPERATION:
+                std::cerr << "GL_INVALID_FRAMEBUFFER_OPERATION - The framebuffer object is not complete.";
+                break;
+            case GL_OUT_OF_MEMORY:
+                std::cerr << "GL_OUT_OF_MEMORY - There is not enough memory left to execute the command.";
+                break;
+            case GL_STACK_UNDERFLOW:
+                std::cerr << "GL_STACK_UNDERFLOW - An attempt has been made to perform an operation that would cause the stack to underflow.";
+                break;
+            case GL_STACK_OVERFLOW:
+                std::cerr << "GL_STACK_OVERFLOW - An attempt has been made to perform an operation that would cause a stack overflow.";
+                break;
+            // Add more cases for other specific OpenGL errors if needed
+            default:
+                std::cerr << "Unknown OpenGL error code: " << error;
+        }
+        std::cerr << std::endl;
+    }
+}
+
+// Basic Perlin Noise implementation (simplified 2D version)
+float perlinNoise(float x, float y) {
+    // ... (Implement Perlin noise algorithm here - this is a simplified example) ...
+    // For a complete Perlin noise implementation, refer to online resources.
+    // This is a placeholder for demonstration -  it will produce very basic noise.
+    float value = 0.0f;
+    float frequency = 1.0f;
+    float amplitude = 1.0f;
+    float maxAmplitude = 0.0f;
+
+    for (int i = 0; i < 4; ++i) { // 4 octaves
+        //float sampleX = x * frequency;
+        //float sampleY = y * frequency;
+        //value += glm::perlin(glm::vec2(sampleX, sampleY)) * amplitude; // Using glm::perlin for simplicity
+        maxAmplitude += amplitude;
+        amplitude *= 0.5f; // Reduce amplitude for each octave
+        frequency *= 2.0f; // Increase frequency for each octave
+    }
+    return value / maxAmplitude; // Normalize to [0, 1] range
+}

windows/src/xlogin00.s

@@ -0,0 +1,18 @@
+.intel_syntax noprefix
+.code64
+
+
+.data
+
+
+.text
+
+
+.global updateVertices_simd
+updateVertices_simd:
+    push rbp
+    mov rbp, rsp #asm
+
+    mov rsp, rbp
+    pop rbp
+    ret