uv mapping onto water good

10 files changed, 297 insertions, 9 deletions

diff --git a/src/arap.cpp b/src/arap.cpp
index 2f10849..9bfbd27 100644
--- a/src/arap.cpp
+++ b/src/arap.cpp
@@ -38,6 +38,8 @@ void ARAP::init
     vertices = m_ocean.get_vertices();
     triangles = m_ocean.get_faces();
 	m_shape.init(vertices, triangles);
+    m_foam_shape.init(vertices, triangles);
+
     m_shape.setColor(0.27f, .803f, .96f);
 
 	// Students, please don't touch this code: get min and max for viewport stuff
@@ -104,8 +106,11 @@ void ARAP::update(double seconds)
     // the last update
 
     m_ocean.fft_prime(m_time);
-	// m_shape.setVertices_and_Normals(m_ocean.get_vertices(), m_ocean.getNormals());
-	m_shape.setVertices(m_ocean.get_vertices());
+    // m_shape.setVertices_and_Normals(m_ocean.get_vertices(), m_ocean.getNormals());
+    m_shape.setVertices(m_ocean.get_vertices());
+
+    FoamConstants foam = m_ocean.getFoamConstants();
+    m_foam_shape.setFoamInputs(m_shape.getVertices(), foam.wavelengths, foam.k_vectors, foam.texCoords);
 
 
      m_time += m_timestep;
diff --git a/src/arap.h b/src/arap.h
index 331cc3d..df31dc0 100644
--- a/src/arap.h
+++ b/src/arap.h
@@ -19,7 +19,8 @@ class ARAP
 {
 private:
     Shape m_shape;
-//    OceanShape m_oceanShape;
+    Shape m_foam_shape;
+
 
 public:
     ARAP();
@@ -43,6 +44,17 @@ public:
         m_shape.draw(shader, mode);
     }
 
+    void drawFoam(Shader *shader, GLenum mode)
+    {
+
+
+        m_foam_shape.draw(shader, mode);
+    }
+
+    double getTime() {
+        return m_time;
+    }
+
     void initGroundPlane(std::string texturePath, float depth, Shader* shader) {
         m_shape.initGroundPlane(texturePath, depth, shader);
     }
diff --git a/src/glwidget.cpp b/src/glwidget.cpp
index c13d476..f2a6d94 100755
--- a/src/glwidget.cpp
+++ b/src/glwidget.cpp
@@ -3,6 +3,11 @@
 #include <QApplication>
 #include <QKeyEvent>
 #include <iostream>
+#define STB_IMAGE_IMPLEMENTATION
+
+#include "stb/stb_image.h"
+
+
 
 #define SPEED 1.5
 #define ROTATE_SPEED 0.0025
@@ -78,6 +83,11 @@ void GLWidget::initializeGL()
     m_pointShader   = new Shader(":resources/shaders/anchorPoint.vert", ":resources/shaders/anchorPoint.geom", ":resources/shaders/anchorPoint.frag");
 //    m_texture_shader = new Shader(":/resources/shaders/texture.vert", ":/resources/shaders/texture.frag");
     m_colorShader   = new Shader(":resources/shaders/color.vert",      ":resources/shaders/color.frag");
+    m_foamShader   = new Shader(":resources/shaders/foam.vert",      ":resources/shaders/foam.frag");
+
+    m_halftone_tex = loadTextureFromFile("/Users/jesswan/Desktop/cs2240/ocean-simulation/resources/images/sky_clouds.png").textureID;
+
+
 
 
     initCaustics();
@@ -335,8 +345,78 @@ void GLWidget::paintGL()
 //    m_pointShader->setUniform("height", height());
 //    m_arap.draw(m_pointShader, GL_POINTS);
 //    m_pointShader->unbind();
+
+        m_foamShader->bind();
+        m_foamShader->setUniform("proj",   m_camera.getProjection());
+        m_foamShader->setUniform("view",   m_camera.getView());
+//        m_foamShader->setUniform("vSize",  m_vSize);
+//        m_foamShader->setUniform("width",  width());
+//        m_foamShader->setUniform("height", height());
+        glUniform1f(glGetUniformLocation(m_foamShader->id(), "time"), m_arap.getTime());
+        glUniform1f(glGetUniformLocation(m_foamShader->id(), "phaseC"), 1.f);
+        m_foamShader->setUniform("widthBounds", m_arap.minCorner[0], m_arap.maxCorner[0]);
+        m_foamShader->setUniform("lengthBounds", m_arap.minCorner[2], m_arap.maxCorner[2]);
+
+        glActiveTexture(GL_TEXTURE5);
+        glBindTexture(GL_TEXTURE_2D, m_halftone_tex);
+        glUniform1i(glGetUniformLocation(m_foamShader->id(), "halftone_texture"), 5);
+
+
+
+
+        m_arap.drawFoam(m_foamShader, GL_TRIANGLES);
+        m_foamShader->unbind();
+
+
 }
 
+TextureData GLWidget::loadTextureFromFile(const char *path)
+{
+    std::string filename = std::string(path);
+
+    GLuint textureID;
+    glGenTextures(1, &textureID);
+
+    int width, height, nrComponents;
+    stbi_set_flip_vertically_on_load(true);
+    unsigned char *data = stbi_load(filename.c_str(), &width, &height, &nrComponents, 0);
+    stbi_set_flip_vertically_on_load(false);
+    if (data)
+    {
+        GLenum format;
+        if (nrComponents == 1)
+            format = GL_RED;
+        else if (nrComponents == 3)
+            format = GL_RGB;
+        else if (nrComponents == 4)
+            format = GL_RGBA;
+
+        glBindTexture(GL_TEXTURE_2D, textureID);
+        glTexImage2D(GL_TEXTURE_2D, 0, format, width, height, 0, format, GL_UNSIGNED_BYTE, data);
+        glGenerateMipmap(GL_TEXTURE_2D);
+
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+        stbi_image_free(data);
+
+    }
+    else
+    {
+        std::cout << "Texture failed to load at path: " << path << std::endl;
+        stbi_image_free(data);
+    }
+
+    TextureData newtex;
+    newtex.textureID = textureID;
+    newtex.height = height;
+    newtex.width = width;
+    return newtex;
+}
+
+
 void GLWidget::resizeGL(int w, int h)
 {
     glViewport(0, 0, w, h);
diff --git a/src/glwidget.h b/src/glwidget.h
index 810829a..dc4ee78 100755
--- a/src/glwidget.h
+++ b/src/glwidget.h
@@ -13,6 +13,12 @@
 #include <QTimer>
 #include <memory>
 
+struct TextureData{
+    GLuint textureID;
+    int width;
+    int height;
+};
+
 class GLWidget : public QOpenGLWidget
 {
     Q_OBJECT
@@ -45,6 +51,8 @@ private:
     void initCaustics();
     void paintCaustics();
 
+    TextureData loadTextureFromFile(const char *path);
+
 private slots:
     // Physics Tick
     void tick();
@@ -57,6 +65,8 @@ private:
     Shader *m_texture_shader;
 
     Shader *m_colorShader;
+    Shader *m_foamShader;
+
 
     GLuint m_fullscreen_vbo;
     GLuint m_fullscreen_vao;
@@ -79,6 +89,9 @@ private:
     float m_vertexSelectionThreshold;
     float m_vSize;
 
+    // FOAM
+    GLuint m_halftone_tex;
+
     // Timing
     QElapsedTimer m_deltaTimeProvider; // For measuring elapsed time
     QTimer        m_intervalTimer;     // For triggering timed events
diff --git a/src/graphics/shape.cpp b/src/graphics/shape.cpp
index 7a33140..7fa5c18 100644
--- a/src/graphics/shape.cpp
+++ b/src/graphics/shape.cpp
@@ -119,6 +119,35 @@ void Shape::setVertices_and_Normals(const vector<Vector3f> &vertices, const vect
     glBindBuffer(GL_ARRAY_BUFFER, 0);
 }
 
+//// FOR FOAMM!!!!
+///
+
+void Shape::setFoamInputs(const vector<Vector3f> &vertices, const vector<float> &wavelengths,
+                          const vector<Vector2f> &waveDirs, const vector<Vector2f> &textures){
+
+
+    vector<Vector3f> verts;
+    vector<Vector3f> norms;
+
+    vector<Vector2f> tex;
+    vector<Vector3f> colors;
+    updateMesh(m_faces, vertices, verts, norms, colors);
+
+    //updateFoam(m_faces, vertices, textureCoords, verts, tex, colors);
+
+
+
+    glBindBuffer(GL_ARRAY_BUFFER, m_surfaceVbo);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(float) * ((verts.size() * 3) + (wavelengths.size() * 1) + (waveDirs.size() * 2) + (tex.size() * 2) + (norms.size() * 3)), nullptr, GL_DYNAMIC_DRAW);
+    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(float) * verts.size() * 3, static_cast<const void *>(verts.data()));
+    glBufferSubData(GL_ARRAY_BUFFER, sizeof(float) * verts.size() * 3, sizeof(float) * wavelengths.size() * 1, static_cast<const void *>(wavelengths.data()));
+    glBufferSubData(GL_ARRAY_BUFFER, sizeof(float) * ((verts.size() * 3) + (wavelengths.size() * 1)), sizeof(float) * waveDirs.size() * 2, static_cast<const void *>(waveDirs.data()));
+    glBufferSubData(GL_ARRAY_BUFFER, sizeof(float) * ((verts.size() * 3) + (wavelengths.size() * 1) + (waveDirs.size() * 2)), sizeof(float) * tex.size() * 2, static_cast<const void *>(tex.data()));
+    glBufferSubData(GL_ARRAY_BUFFER, sizeof(float) * ((verts.size() * 3) + (wavelengths.size() * 1) + (waveDirs.size() * 2) + (tex.size() * 2)), sizeof(float) * (norms.size() * 3), static_cast<const void *>(norms.data()));
+
+    glBindBuffer(GL_ARRAY_BUFFER, 0);
+}
+
 // ================== Model Matrix
 
 void Shape::setModelMatrix(const Affine3f &model) { m_modelMatrix = model.matrix(); }
@@ -325,6 +354,28 @@ void Shape::updateMesh(const std::vector<Eigen::Vector3i> &faces,
     }
 }
 
+void Shape::updateFoam(const std::vector<Eigen::Vector3i> &faces,
+                       const std::vector<Eigen::Vector3f> &vertices,
+                       const std::vector<Eigen::Vector2f> &texCoords,
+
+                       std::vector<Eigen::Vector3f>& verts,
+                       std::vector<Eigen::Vector2f>& tex,
+                       std::vector<Eigen::Vector3f>& colors)
+{
+    //verts.reserve(faces.size() * 3);
+    tex.reserve(faces.size() * 3);
+
+    for (const Eigen::Vector3i& face : faces) {
+
+        for (auto& v: {face[0], face[1], face[2]}) {
+            tex.push_back(texCoords[v]);
+            //std::cout << texCoords[v] << std::endl;
+            //verts.push_back(vertices[v]);
+
+        }
+    }
+}
+
 void Shape::updateMesh_withNormals(const std::vector<Eigen::Vector3i> &faces,
                        const std::vector<Eigen::Vector3f> &vertices,
                        const std::vector<Eigen::Vector3f> &calculated_norms,
diff --git a/src/graphics/shape.h b/src/graphics/shape.h
index 2915190..ef1c532 100644
--- a/src/graphics/shape.h
+++ b/src/graphics/shape.h
@@ -31,6 +31,15 @@ public:
     void init(const std::vector<Eigen::Vector3f> &vertices, const std::vector<Eigen::Vector3i> &triangles);
     void setVertices(const std::vector<Eigen::Vector3f> &vertices);
     void setVertices_and_Normals(const std::vector<Eigen::Vector3f> &vertices, const std::vector<Eigen::Vector3f> &normals);
+    void setFoamInputs(const std::vector<Eigen::Vector3f> &verts, const std::vector<float> &wavelengths,
+                       const std::vector<Eigen::Vector2f> &waveDirs, const std::vector<Eigen::Vector2f> &textureCoords);
+    void updateFoam(const std::vector<Eigen::Vector3i> &faces,
+                           const std::vector<Eigen::Vector3f> &vertices,
+                           const std::vector<Eigen::Vector2f> &texCoords,
+
+                           std::vector<Eigen::Vector3f>& verts,
+                           std::vector<Eigen::Vector2f>& tex,
+                           std::vector<Eigen::Vector3f>& colors);
 
 
     void setModelMatrix(const Eigen::Affine3f &model);
diff --git a/src/ocean/halftone.cpp b/src/ocean/halftone.cpp
new file mode 100644
index 0000000..6aa59cb
--- /dev/null
+++ b/src/ocean/halftone.cpp
@@ -0,0 +1,47 @@
+#include "halftone.h"
+#include <cmath>
+#include <vector>
+
+halftone::halftone()
+{
+
+}
+
+//void halftone::init(int n, int m, float density){
+//    N = n;
+//    M = m;
+//   // std::vector<std::vector<int>> m_halftone;
+//    // 1. intiialize pattern array with density
+//    for (int i=0; i<N; i++){
+//        for (int j=0; j<M; j++){
+//            // determine whether to place a 1 or 0 here based on density
+
+//            // generate random number 0-1
+//            float r = ((float) rand() / (float) RAND_MAX);
+//            if (r < density){
+//                m_halftone[i][j] = 1;
+//            } else {
+//                m_halftone[i][j] = 0;
+//            }
+//        }
+//    }
+
+//}
+
+//void halftone::apply_gaussian(){
+//    for (int i=0; i<N; i++){
+//        for (int j=0; j<M; j++){
+//           m_halftone[i][j] = radial_gaussian(i, j);
+//        }
+//    }
+
+//}
+
+//float halftone::radial_gaussian(int i, int j){
+//    float r = sqrt((i-.5*N)*(i-.5*N) + (j-.5*M)*(j-.5*M));
+//    float result = exp(-(r*r) / (2.f*m_sigma*m_sigma));
+
+//    return result;
+
+//}
+
diff --git a/src/ocean/halftone.h b/src/ocean/halftone.h
new file mode 100644
index 0000000..e913eac
--- /dev/null
+++ b/src/ocean/halftone.h
@@ -0,0 +1,19 @@
+#ifndef HALFTONE_H
+#define HALFTONE_H
+
+
+#include <vector>
+class halftone
+{
+public:
+    halftone();
+
+private:
+    int N = 0;
+    int M = 0;
+    float m_sigma = 24.f;
+    std::vector<std::vector<int>> m_halftone;
+
+};
+
+#endif // HALFTONE_H
diff --git a/src/ocean/ocean_alt.cpp b/src/ocean/ocean_alt.cpp
index 025e89b..9ba0042 100644
--- a/src/ocean/ocean_alt.cpp
+++ b/src/ocean/ocean_alt.cpp
@@ -12,6 +12,7 @@ ocean_alt::ocean_alt()
 
 // initializes static constants (aka they are not time dependent)
 void ocean_alt::init_wave_index_constants(){
+    float tex_step = 1.f/num_rows;
 
     for (int i=0; i<N; i++){
         Eigen::Vector2i m_n = index_1d_to_2d(i);
@@ -22,6 +23,23 @@ void ocean_alt::init_wave_index_constants(){
         Eigen::Vector2d k_conj = get_k_vector(-n_prime, m_prime);
 
 
+        Eigen::Vector3f v = Eigen::Vector3f(0,0,1);
+        Eigen::Vector3f norm = Eigen::Vector3f(0,1,0);
+        if (abs(norm[1]) < 1.f){
+            v = (Eigen::Vector3f(0,1,0) - norm[1]*norm).normalized();
+        }
+        Eigen::Vector3f u = norm.cross(v).normalized();
+
+        float u_coord = u.dot(Eigen::Vector3f(n_prime, 0, m_prime)) / 64.f;
+        float v_coord = v.dot(Eigen::Vector3f(n_prime, 0, m_prime)) / 64.f;
+
+        std::cout << u_coord << ", " << v_coord << std::endl;
+
+
+        // texture coord:
+        Eigen::Vector2f texCoord = Eigen::Vector2f(1, 1);
+
+
         // store h0'(n,m) and w'(n,m) for every index, to be used for later
         Eigen::Vector2d h0_prime = h_0_prime(k);
 
@@ -36,7 +54,6 @@ void ocean_alt::init_wave_index_constants(){
         wave_const.h0_prime = h0_prime;
         wave_const.h0_prime_conj = h0_prime_conj;
         wave_const.w_prime = w_prime;
-        wave_const.w_prime = w_prime;
         wave_const.base_horiz_pos = get_horiz_pos(i);
         wave_const.k_vector = k;
 
@@ -48,6 +65,13 @@ void ocean_alt::init_wave_index_constants(){
         m_slopes.push_back(Eigen::Vector2d(0.0, 0.0));
         m_normals.push_back(Eigen::Vector3f(0.0, 1.0, 0.0));
 
+        // initialize foam constant vectors
+        m_foam_constants.k_vectors.push_back(Eigen::Vector2f(k[0], k[1]));
+        m_foam_constants.positions.push_back(Eigen::Vector3f(0,0,0));
+        m_foam_constants.wavelengths.push_back(0);
+        m_foam_constants.texCoords.push_back(texCoord);
+
+
     }
 }
 
@@ -293,7 +317,14 @@ std::vector<Eigen::Vector3f> ocean_alt::get_vertices()
         vertices.push_back(Eigen::Vector3f(horiz_pos[0] + disp[0], height, horiz_pos[1] + disp[1]));
         m_normals[i] = norm.normalized();//Eigen::Vector3f(-slope[0], 1.0, -slope[1]).normalized();
         //std::cout << "normal: " << m_normals[i] << std::endl
+
+
+
     }
+
+    // populate foam constants
+    m_foam_constants.positions = vertices;
+
     return vertices;
 }
 
@@ -450,4 +481,4 @@ std::vector<Eigen::Vector2d> ocean_alt::fast_fft
 	}
 
 	return h;
-}
\ No newline at end of file
+}
diff --git a/src/ocean/ocean_alt.h b/src/ocean/ocean_alt.h
index 4bb1d54..dc9bb33 100644
--- a/src/ocean/ocean_alt.h
+++ b/src/ocean/ocean_alt.h
@@ -20,6 +20,13 @@ struct WaveIndexConstant{
     Eigen::Vector2d k_vector = Eigen::Vector2d(0.f, 0.f); // static horiz pos with no displacement
 };
 
+struct FoamConstants{
+    std::vector<Eigen::Vector3f> positions;
+    std::vector<Eigen::Vector2f> k_vectors;
+    std::vector<float> wavelengths;
+    std::vector<Eigen::Vector2f> texCoords;
+};
+
 class ocean_alt
 {
 public:
@@ -30,6 +37,10 @@ public:
     void fft_prime(double t);
     std::vector<Eigen::Vector3f> getNormals();
 
+    FoamConstants getFoamConstants(){
+        return m_foam_constants;
+    }
+
 
 
 
@@ -49,6 +60,10 @@ private:
     std::pair<double, double> sample_complex_gaussian();
 
 
+    // FOAM
+    std::vector<float> m_saturation;
+
+
 
 
 
@@ -63,11 +78,11 @@ private:
 	const double Lx = 512.0;
 	const double Lz = 512.0;
 
-	const int num_rows = 256;
-	const int num_cols = 256;
+    const int num_rows = 32;
+    const int num_cols = 32;
 
 	const int N = num_rows*num_cols; // total number of grid points
-	const double lambda = 0; // how much displacement matters
+    const double lambda = 0.3; // how much displacement matters
 	const double spacing = 35.0; // spacing between grid points
 
 	const double A = 100; // numeric constant for the Phillips spectrum
@@ -81,7 +96,13 @@ private:
     std::vector<Eigen::Vector2d> m_slopes; // current displacement vector for each K
     //std::vector<Eigen::Vector3f> m_slope_vectors; // current displacement vector for each K
 
-    std::vector<Eigen::Vector3f> m_normals; // current displacement vector for each K
+    std::vector<Eigen::Vector3f> m_normals; // normal calculations
+
+    // FOR FOAM:
+    FoamConstants m_foam_constants;
+
+
+