362 lines
16 KiB
C++
362 lines
16 KiB
C++
/*
|
|
* 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
|
|
|
|
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), seaLevelOffset(-2.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});
|
|
#if (0)
|
|
gerstnerWaves.push_back({0.12f, 6.5f, 1.2f, glm::normalize(glm::vec2(1.0f, 0.8f)), 0.0f});
|
|
gerstnerWaves.push_back({0.10f, 9.0f, 1.0f, glm::normalize(glm::vec2(-1.0f, 0.4f)), 1.0f});
|
|
gerstnerWaves.push_back({0.08f, 13.0f, 0.8f, glm::normalize(glm::vec2(0.2f, -1.0f)), 2.2f});
|
|
gerstnerWaves.push_back({0.07f, 16.0f, 0.6f, glm::normalize(glm::vec2(-0.6f, -1.0f)), 3.0f});
|
|
gerstnerWaves.push_back({0.11f, 7.5f, 1.1f, glm::normalize(glm::vec2(0.0f, 1.0f)), 0.5f});
|
|
#endif
|
|
#if (0)
|
|
gerstnerWaves.push_back({0.18f, 7.0f, 0.9f, glm::normalize(glm::vec2(0.8f, 0.6f)), 0.0f});
|
|
gerstnerWaves.push_back({0.15f, 10.0f, 0.8f, glm::normalize(glm::vec2(-0.9f, 0.4f)), 1.1f});
|
|
gerstnerWaves.push_back({0.13f, 14.0f, 0.7f, glm::normalize(glm::vec2(0.3f, -1.0f)), 2.3f});
|
|
gerstnerWaves.push_back({0.12f, 18.0f, 0.6f, glm::normalize(glm::vec2(-0.6f, -1.0f)), 3.0f});
|
|
gerstnerWaves.push_back({0.16f, 8.5f, 0.85f, glm::normalize(glm::vec2(0.0f, 1.0f)), 0.7f});
|
|
#endif
|
|
#if (1)
|
|
gerstnerWaves.push_back({0.3f, 5.0f, 2.0f, glm::normalize(glm::vec2(1.0f, 1.0f)), 0.0f});
|
|
gerstnerWaves.push_back({0.2f, 8.0f, 1.5f, glm::normalize(glm::vec2(-1.0f, 0.5f)), 1.0f});
|
|
gerstnerWaves.push_back({0.15f, 12.0f, 1.0f, glm::normalize(glm::vec2(0.3f, -1.0f)), 2.5f});
|
|
gerstnerWaves.push_back({0.1f, 15.0f, 0.8f, glm::normalize(glm::vec2(-0.7f, -0.7f)), 3.7f});
|
|
gerstnerWaves.push_back({0.25f, 7.0f, 1.8f, glm::normalize(glm::vec2(0.0f, 1.0f)), 0.8f});
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Ocean::init()
|
|
{
|
|
generateGrid();
|
|
createBuffers(); // Create VBOs and IBO
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void Ocean::update(float deltaTime)
|
|
{
|
|
time += deltaTime;
|
|
std::vector<glm::vec3> updatedVertices_vec = vertices;
|
|
std::vector<glm::vec3> updatedNormals_vec(vertices.size());
|
|
updateVertices(&updatedVertices_vec, &updatedNormals_vec, originalWorldX.data(), originalWorldZ.data(), gridSize, time);
|
|
updateBuffers(updatedVertices_vec, updatedNormals_vec);
|
|
}
|
|
|
|
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::updateVertices(std::vector<glm::vec3> * updatedVertices, std::vector<glm::vec3> * updatedNormals, float * originalWorldX_, float * originalWorldZ_, int _grid_size, float time)
|
|
{
|
|
|
|
for (int x = 0; x < _grid_size; ++x)
|
|
{
|
|
for (int z = 0; z < _grid_size; ++z)
|
|
{
|
|
|
|
glm::vec3 &vertex = (*updatedVertices)[x * _grid_size + z]; // Use reference to modify directly
|
|
float originalX = originalWorldX_[x * _grid_size + z];
|
|
float originalZ = originalWorldZ_[x * _grid_size + z];
|
|
vertex.y = getWaveHeight(vertex.x, vertex.z, time);
|
|
(*updatedNormals)[x * gridSize + z] = getWaveNormal(originalX, originalZ, time); // Calculate normal using original coords
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
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 + seaLevelOffset;
|
|
}
|
|
|
|
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;
|
|
}
|
|
/*
|
|
if(c<8){
|
|
float a = 2.0f * glm::pi<float>() * time / wave.wavelength;
|
|
puts("");
|
|
printf("2*pi*time/wave.wavelength: %f \n",a);
|
|
printf("sin(2*pi*time/wave.wavelength): %f \n",sin(a));
|
|
printf("k*dot: %f \n",k * dotProduct);
|
|
printf("w*time: %f \n",w * time);
|
|
printf("wave phase: %f \n",wave.phase);
|
|
printf("k*dot - w*time + phase: %f \n",k * dotProduct-w*time+wave.phase);
|
|
printf("sin(k*dot - w*time + phase: %f )\n",sin(k * dotProduct-w*time+wave.phase));
|
|
printf("res: %f pariodic: %f dot: %f time: %f wave_x x: %f %f wave_y z: %f %f\n",waveHeightValue,periodicAmplitude,dotProduct,time,wave.direction.x,x,wave.direction.y,z);
|
|
puts("");
|
|
c++;
|
|
if(c==7){
|
|
puts("");
|
|
}
|
|
}
|
|
*/
|
|
|
|
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
|
|
);
|
|
|
|
}
|
|
/*
|
|
auto cros = glm::cross(tangentZ, tangentX);
|
|
if(c==0&&time!=0){
|
|
puts("tangent:");
|
|
c++;
|
|
std::cout<<tangentX.x<<std::endl;
|
|
std::cout<<tangentX.z<<std::endl;
|
|
|
|
std::cout<<tangentZ.x<<std::endl;
|
|
std::cout<<tangentZ.z<<std::endl;
|
|
|
|
std::cout<<tangentX.y<<std::endl;
|
|
std::cout<<tangentZ.y<<std::endl;
|
|
puts("cross:");
|
|
std::cout<<cros.x<<std::endl;
|
|
std::cout<<cros.y<<std::endl;
|
|
std::cout<<cros.z<<std::endl;
|
|
}
|
|
*/
|
|
return glm::normalize(glm::cross(tangentZ, tangentX));
|
|
}
|
|
|
|
|
|
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];
|
|
}
|
|
|
|
|
|
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, originalWorldX.data(), originalWorldZ.data(), gridSize, 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;
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
Ocean::~Ocean()
|
|
{
|
|
cleanup(); // Call cleanup to release OpenGL resources
|
|
}
|
|
|
|
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;
|
|
}
|