examples/wave.c - third_party/glfw - Git at Google

 /*****************************************************************************
  * Wave Simulation in OpenGL
  * (C) 2002 Jakob Thomsen
  * http://home.in.tum.de/~thomsen
  * Modified for GLFW by Sylvain Hellegouarch - sh@programmationworld.com
  * Modified for variable frame rate by Marcus Geelnard
  * 2003-Jan-31: Minor cleanups and speedups / MG
  * 2010-10-24: Formatting and cleanup - Camilla Löwy
  *****************************************************************************/

 #if defined(_MSC_VER)
  // Make MS math.h define M_PI
  #define _USE_MATH_DEFINES
 #endif

 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>

 #include <glad/gl.h>
 #define GLFW_INCLUDE_NONE
 #include <GLFW/glfw3.h>

 #include <linmath.h>

 // Maximum delta T to allow for differential calculations
 #define MAX_DELTA_T 0.01

 // Animation speed (10.0 looks good)
 #define ANIMATION_SPEED 10.0

 GLfloat alpha = 210.f, beta = -70.f;
 GLfloat zoom = 2.f;

 double cursorX;
 double cursorY;

 struct Vertex
 {
     GLfloat x, y, z;
     GLfloat r, g, b;
 };

 #define GRIDW 50
 #define GRIDH 50
 #define VERTEXNUM (GRIDW*GRIDH)

 #define QUADW (GRIDW - 1)
 #define QUADH (GRIDH - 1)
 #define QUADNUM (QUADW*QUADH)

 GLuint quad[4 * QUADNUM];
 struct Vertex vertex[VERTEXNUM];

 /* The grid will look like this:
  *
  *      3   4   5
  *      *---*---*
  *      |   |   |
  *      | 0 | 1 |
  *      |   |   |
  *      *---*---*
  *      0   1   2
  */

 //========================================================================
 // Initialize grid geometry
 //========================================================================

 void init_vertices(void)
 {
     int x, y, p;

     // Place the vertices in a grid
     for (y = 0;  y < GRIDH;  y++)
     {
         for (x = 0;  x < GRIDW;  x++)
         {
             p = y * GRIDW + x;

             vertex[p].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2);
             vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2);
             vertex[p].z = 0;

             if ((x % 4 < 2) ^ (y % 4 < 2))
                 vertex[p].r = 0.0;
             else
                 vertex[p].r = 1.0;

             vertex[p].g = (GLfloat) y / (GLfloat) GRIDH;
             vertex[p].b = 1.f - ((GLfloat) x / (GLfloat) GRIDW + (GLfloat) y / (GLfloat) GRIDH) / 2.f;
         }
     }

     for (y = 0;  y < QUADH;  y++)
     {
         for (x = 0;  x < QUADW;  x++)
         {
             p = 4 * (y * QUADW + x);

             quad[p + 0] = y       * GRIDW + x;     // Some point
             quad[p + 1] = y       * GRIDW + x + 1; // Neighbor at the right side
             quad[p + 2] = (y + 1) * GRIDW + x + 1; // Upper right neighbor
             quad[p + 3] = (y + 1) * GRIDW + x;     // Upper neighbor
         }
     }
 }

 double dt;
 double p[GRIDW][GRIDH];
 double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH];
 double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH];

 //========================================================================
 // Initialize grid
 //========================================================================

 void init_grid(void)
 {
     int x, y;
     double dx, dy, d;

     for (y = 0; y < GRIDH;  y++)
     {
         for (x = 0; x < GRIDW;  x++)
         {
             dx = (double) (x - GRIDW / 2);
             dy = (double) (y - GRIDH / 2);
             d = sqrt(dx * dx + dy * dy);
             if (d < 0.1 * (double) (GRIDW / 2))
             {
                 d = d * 10.0;
                 p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0;
             }
             else
                 p[x][y] = 0.0;

             vx[x][y] = 0.0;
             vy[x][y] = 0.0;
         }
     }
 }


 //========================================================================
 // Draw scene
 //========================================================================

 void draw_scene(GLFWwindow* window)
 {
     // Clear the color and depth buffers
     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

     // We don't want to modify the projection matrix
     glMatrixMode(GL_MODELVIEW);
     glLoadIdentity();

     // Move back
     glTranslatef(0.0, 0.0, -zoom);
     // Rotate the view
     glRotatef(beta, 1.0, 0.0, 0.0);
     glRotatef(alpha, 0.0, 0.0, 1.0);

     glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad);

     glfwSwapBuffers(window);
 }


 //========================================================================
 // Initialize Miscellaneous OpenGL state
 //========================================================================

 void init_opengl(void)
 {
     // Use Gouraud (smooth) shading
     glShadeModel(GL_SMOOTH);

     // Switch on the z-buffer
     glEnable(GL_DEPTH_TEST);

     glEnableClientState(GL_VERTEX_ARRAY);
     glEnableClientState(GL_COLOR_ARRAY);
     glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), vertex);
     glColorPointer(3, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r); // Pointer to the first color

     glPointSize(2.0);

     // Background color is black
     glClearColor(0, 0, 0, 0);
 }


 //========================================================================
 // Modify the height of each vertex according to the pressure
 //========================================================================

 void adjust_grid(void)
 {
     int pos;
     int x, y;

     for (y = 0; y < GRIDH;  y++)
     {
         for (x = 0;  x < GRIDW;  x++)
         {
             pos = y * GRIDW + x;
             vertex[pos].z = (float) (p[x][y] * (1.0 / 50.0));
         }
     }
 }


 //========================================================================
 // Calculate wave propagation
 //========================================================================

 void calc_grid(void)
 {
     int x, y, x2, y2;
     double time_step = dt * ANIMATION_SPEED;

     // Compute accelerations
     for (x = 0;  x < GRIDW;  x++)
     {
         x2 = (x + 1) % GRIDW;
         for(y = 0; y < GRIDH; y++)
             ax[x][y] = p[x][y] - p[x2][y];
     }

     for (y = 0;  y < GRIDH;  y++)
     {
         y2 = (y + 1) % GRIDH;
         for(x = 0; x < GRIDW; x++)
             ay[x][y] = p[x][y] - p[x][y2];
     }

     // Compute speeds
     for (x = 0;  x < GRIDW;  x++)
     {
         for (y = 0;  y < GRIDH;  y++)
         {
             vx[x][y] = vx[x][y] + ax[x][y] * time_step;
             vy[x][y] = vy[x][y] + ay[x][y] * time_step;
         }
     }

     // Compute pressure
     for (x = 1;  x < GRIDW;  x++)
     {
         x2 = x - 1;
         for (y = 1;  y < GRIDH;  y++)
         {
             y2 = y - 1;
             p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step;
         }
     }
 }


 //========================================================================
 // Print errors
 //========================================================================

 static void error_callback(int error, const char* description)
 {
     fprintf(stderr, "Error: %s\n", description);
 }


 //========================================================================
 // Handle key strokes
 //========================================================================

 void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
 {
     if (action != GLFW_PRESS)
         return;

     switch (key)
     {
         case GLFW_KEY_ESCAPE:
             glfwSetWindowShouldClose(window, GLFW_TRUE);
             break;
         case GLFW_KEY_SPACE:
             init_grid();
             break;
         case GLFW_KEY_LEFT:
             alpha += 5;
             break;
         case GLFW_KEY_RIGHT:
             alpha -= 5;
             break;
         case GLFW_KEY_UP:
             beta -= 5;
             break;
         case GLFW_KEY_DOWN:
             beta += 5;
             break;
         case GLFW_KEY_PAGE_UP:
             zoom -= 0.25f;
             if (zoom < 0.f)
                 zoom = 0.f;
             break;
         case GLFW_KEY_PAGE_DOWN:
             zoom += 0.25f;
             break;
         default:
             break;
     }
 }


 //========================================================================
 // Callback function for mouse button events
 //========================================================================

 void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
 {
     if (button != GLFW_MOUSE_BUTTON_LEFT)
         return;

     if (action == GLFW_PRESS)
     {
         glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
         glfwGetCursorPos(window, &cursorX, &cursorY);
     }
     else
         glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
 }


 //========================================================================
 // Callback function for cursor motion events
 //========================================================================

 void cursor_position_callback(GLFWwindow* window, double x, double y)
 {
     if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
     {
         alpha += (GLfloat) (x - cursorX) / 10.f;
         beta += (GLfloat) (y - cursorY) / 10.f;

         cursorX = x;
         cursorY = y;
     }
 }


 //========================================================================
 // Callback function for scroll events
 //========================================================================

 void scroll_callback(GLFWwindow* window, double x, double y)
 {
     zoom += (float) y / 4.f;
     if (zoom < 0)
         zoom = 0;
 }


 //========================================================================
 // Callback function for framebuffer resize events
 //========================================================================

 void framebuffer_size_callback(GLFWwindow* window, int width, int height)
 {
     float ratio = 1.f;
     mat4x4 projection;

     if (height > 0)
         ratio = (float) width / (float) height;

     // Setup viewport
     glViewport(0, 0, width, height);

     // Change to the projection matrix and set our viewing volume
     glMatrixMode(GL_PROJECTION);
     mat4x4_perspective(projection,
                        60.f * (float) M_PI / 180.f,
                        ratio,
                        1.f, 1024.f);
     glLoadMatrixf((const GLfloat*) projection);
 }


 //========================================================================
 // main
 //========================================================================

 int main(int argc, char* argv[])
 {
     GLFWwindow* window;
     double t, dt_total, t_old;
     int width, height;

     glfwSetErrorCallback(error_callback);

     if (!glfwInit())
         exit(EXIT_FAILURE);

     window = glfwCreateWindow(640, 480, "Wave Simulation", NULL, NULL);
     if (!window)
     {
         glfwTerminate();
         exit(EXIT_FAILURE);
     }

     glfwSetKeyCallback(window, key_callback);
     glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
     glfwSetMouseButtonCallback(window, mouse_button_callback);
     glfwSetCursorPosCallback(window, cursor_position_callback);
     glfwSetScrollCallback(window, scroll_callback);

     glfwMakeContextCurrent(window);
     gladLoadGL(glfwGetProcAddress);
     glfwSwapInterval(1);

     glfwGetFramebufferSize(window, &width, &height);
     framebuffer_size_callback(window, width, height);

     // Initialize OpenGL
     init_opengl();

     // Initialize simulation
     init_vertices();
     init_grid();
     adjust_grid();

     // Initialize timer
     t_old = glfwGetTime() - 0.01;

     while (!glfwWindowShouldClose(window))
     {
         t = glfwGetTime();
         dt_total = t - t_old;
         t_old = t;

         // Safety - iterate if dt_total is too large
         while (dt_total > 0.f)
         {
             // Select iteration time step
             dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
             dt_total -= dt;

             // Calculate wave propagation
             calc_grid();
         }

         // Compute height of each vertex
         adjust_grid();

         // Draw wave grid to OpenGL display
         draw_scene(window);

         glfwPollEvents();
     }

     glfwTerminate();
     exit(EXIT_SUCCESS);
 }
	/*****************************************************************************
	* Wave Simulation in OpenGL
	* (C) 2002 Jakob Thomsen
	* http://home.in.tum.de/~thomsen
	* Modified for GLFW by Sylvain Hellegouarch - sh@programmationworld.com
	* Modified for variable frame rate by Marcus Geelnard
	* 2003-Jan-31: Minor cleanups and speedups / MG
	* 2010-10-24: Formatting and cleanup - Camilla Löwy
	*****************************************************************************/

	#if defined(_MSC_VER)
	// Make MS math.h define M_PI
	#define _USE_MATH_DEFINES
	#endif

	#include <stdio.h>
	#include <stdlib.h>
	#include <math.h>

	#include <glad/gl.h>
	#define GLFW_INCLUDE_NONE
	#include <GLFW/glfw3.h>

	#include <linmath.h>

	// Maximum delta T to allow for differential calculations
	#define MAX_DELTA_T 0.01

	// Animation speed (10.0 looks good)
	#define ANIMATION_SPEED 10.0

	GLfloat alpha = 210.f, beta = -70.f;
	GLfloat zoom = 2.f;

	double cursorX;
	double cursorY;

	struct Vertex
	{
	GLfloat x, y, z;
	GLfloat r, g, b;
	};

	#define GRIDW 50
	#define GRIDH 50
	#define VERTEXNUM (GRIDW*GRIDH)

	#define QUADW (GRIDW - 1)
	#define QUADH (GRIDH - 1)
	#define QUADNUM (QUADW*QUADH)

	GLuint quad[4 * QUADNUM];
	struct Vertex vertex[VERTEXNUM];

	/* The grid will look like this:
	*
	* 3 4 5
	* ------*
	* \| \| \|
	* \| 0 \| 1 \|
	* \| \| \|
	* ------*
	* 0 1 2
	*/

	//========================================================================
	// Initialize grid geometry
	//========================================================================

	void init_vertices(void)
	{
	int x, y, p;

	// Place the vertices in a grid
	for (y = 0; y < GRIDH; y++)
	{
	for (x = 0; x < GRIDW; x++)
	{
	p = y * GRIDW + x;

	vertex[p].x = (GLfloat) (x - GRIDW / 2) / (GLfloat) (GRIDW / 2);
	vertex[p].y = (GLfloat) (y - GRIDH / 2) / (GLfloat) (GRIDH / 2);
	vertex[p].z = 0;

	if ((x % 4 < 2) ^ (y % 4 < 2))
	vertex[p].r = 0.0;
	else
	vertex[p].r = 1.0;

	vertex[p].g = (GLfloat) y / (GLfloat) GRIDH;
	vertex[p].b = 1.f - ((GLfloat) x / (GLfloat) GRIDW + (GLfloat) y / (GLfloat) GRIDH) / 2.f;
	}
	}

	for (y = 0; y < QUADH; y++)
	{
	for (x = 0; x < QUADW; x++)
	{
	p = 4 * (y * QUADW + x);

	quad[p + 0] = y * GRIDW + x; // Some point
	quad[p + 1] = y * GRIDW + x + 1; // Neighbor at the right side
	quad[p + 2] = (y + 1) * GRIDW + x + 1; // Upper right neighbor
	quad[p + 3] = (y + 1) * GRIDW + x; // Upper neighbor
	}
	}
	}

	double dt;
	double p[GRIDW][GRIDH];
	double vx[GRIDW][GRIDH], vy[GRIDW][GRIDH];
	double ax[GRIDW][GRIDH], ay[GRIDW][GRIDH];

	//========================================================================
	// Initialize grid
	//========================================================================

	void init_grid(void)
	{
	int x, y;
	double dx, dy, d;

	for (y = 0; y < GRIDH; y++)
	{
	for (x = 0; x < GRIDW; x++)
	{
	dx = (double) (x - GRIDW / 2);
	dy = (double) (y - GRIDH / 2);
	d = sqrt(dx * dx + dy * dy);
	if (d < 0.1 * (double) (GRIDW / 2))
	{
	d = d * 10.0;
	p[x][y] = -cos(d * (M_PI / (double)(GRIDW * 4))) * 100.0;
	}
	else
	p[x][y] = 0.0;

	vx[x][y] = 0.0;
	vy[x][y] = 0.0;
	}
	}
	}


	//========================================================================
	// Draw scene
	//========================================================================

	void draw_scene(GLFWwindow* window)
	{
	// Clear the color and depth buffers
	glClear(GL_COLOR_BUFFER_BIT \| GL_DEPTH_BUFFER_BIT);

	// We don't want to modify the projection matrix
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();

	// Move back
	glTranslatef(0.0, 0.0, -zoom);
	// Rotate the view
	glRotatef(beta, 1.0, 0.0, 0.0);
	glRotatef(alpha, 0.0, 0.0, 1.0);

	glDrawElements(GL_QUADS, 4 * QUADNUM, GL_UNSIGNED_INT, quad);

	glfwSwapBuffers(window);
	}


	//========================================================================
	// Initialize Miscellaneous OpenGL state
	//========================================================================

	void init_opengl(void)
	{
	// Use Gouraud (smooth) shading
	glShadeModel(GL_SMOOTH);

	// Switch on the z-buffer
	glEnable(GL_DEPTH_TEST);

	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	glVertexPointer(3, GL_FLOAT, sizeof(struct Vertex), vertex);
	glColorPointer(3, GL_FLOAT, sizeof(struct Vertex), &vertex[0].r); // Pointer to the first color

	glPointSize(2.0);

	// Background color is black
	glClearColor(0, 0, 0, 0);
	}


	//========================================================================
	// Modify the height of each vertex according to the pressure
	//========================================================================

	void adjust_grid(void)
	{
	int pos;
	int x, y;

	for (y = 0; y < GRIDH; y++)
	{
	for (x = 0; x < GRIDW; x++)
	{
	pos = y * GRIDW + x;
	vertex[pos].z = (float) (p[x][y] * (1.0 / 50.0));
	}
	}
	}


	//========================================================================
	// Calculate wave propagation
	//========================================================================

	void calc_grid(void)
	{
	int x, y, x2, y2;
	double time_step = dt * ANIMATION_SPEED;

	// Compute accelerations
	for (x = 0; x < GRIDW; x++)
	{
	x2 = (x + 1) % GRIDW;
	for(y = 0; y < GRIDH; y++)
	ax[x][y] = p[x][y] - p[x2][y];
	}

	for (y = 0; y < GRIDH; y++)
	{
	y2 = (y + 1) % GRIDH;
	for(x = 0; x < GRIDW; x++)
	ay[x][y] = p[x][y] - p[x][y2];
	}

	// Compute speeds
	for (x = 0; x < GRIDW; x++)
	{
	for (y = 0; y < GRIDH; y++)
	{
	vx[x][y] = vx[x][y] + ax[x][y] * time_step;
	vy[x][y] = vy[x][y] + ay[x][y] * time_step;
	}
	}

	// Compute pressure
	for (x = 1; x < GRIDW; x++)
	{
	x2 = x - 1;
	for (y = 1; y < GRIDH; y++)
	{
	y2 = y - 1;
	p[x][y] = p[x][y] + (vx[x2][y] - vx[x][y] + vy[x][y2] - vy[x][y]) * time_step;
	}
	}
	}


	//========================================================================
	// Print errors
	//========================================================================

	static void error_callback(int error, const char* description)
	{
	fprintf(stderr, "Error: %s\n", description);
	}


	//========================================================================
	// Handle key strokes
	//========================================================================

	void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
	{
	if (action != GLFW_PRESS)
	return;

	switch (key)
	{
	case GLFW_KEY_ESCAPE:
	glfwSetWindowShouldClose(window, GLFW_TRUE);
	break;
	case GLFW_KEY_SPACE:
	init_grid();
	break;
	case GLFW_KEY_LEFT:
	alpha += 5;
	break;
	case GLFW_KEY_RIGHT:
	alpha -= 5;
	break;
	case GLFW_KEY_UP:
	beta -= 5;
	break;
	case GLFW_KEY_DOWN:
	beta += 5;
	break;
	case GLFW_KEY_PAGE_UP:
	zoom -= 0.25f;
	if (zoom < 0.f)
	zoom = 0.f;
	break;
	case GLFW_KEY_PAGE_DOWN:
	zoom += 0.25f;
	break;
	default:
	break;
	}
	}


	//========================================================================
	// Callback function for mouse button events
	//========================================================================

	void mouse_button_callback(GLFWwindow* window, int button, int action, int mods)
	{
	if (button != GLFW_MOUSE_BUTTON_LEFT)
	return;

	if (action == GLFW_PRESS)
	{
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
	glfwGetCursorPos(window, &cursorX, &cursorY);
	}
	else
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
	}


	//========================================================================
	// Callback function for cursor motion events
	//========================================================================

	void cursor_position_callback(GLFWwindow* window, double x, double y)
	{
	if (glfwGetInputMode(window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
	{
	alpha += (GLfloat) (x - cursorX) / 10.f;
	beta += (GLfloat) (y - cursorY) / 10.f;

	cursorX = x;
	cursorY = y;
	}
	}


	//========================================================================
	// Callback function for scroll events
	//========================================================================

	void scroll_callback(GLFWwindow* window, double x, double y)
	{
	zoom += (float) y / 4.f;
	if (zoom < 0)
	zoom = 0;
	}


	//========================================================================
	// Callback function for framebuffer resize events
	//========================================================================

	void framebuffer_size_callback(GLFWwindow* window, int width, int height)
	{
	float ratio = 1.f;
	mat4x4 projection;

	if (height > 0)
	ratio = (float) width / (float) height;

	// Setup viewport
	glViewport(0, 0, width, height);

	// Change to the projection matrix and set our viewing volume
	glMatrixMode(GL_PROJECTION);
	mat4x4_perspective(projection,
	60.f * (float) M_PI / 180.f,
	ratio,
	1.f, 1024.f);
	glLoadMatrixf((const GLfloat*) projection);
	}


	//========================================================================
	// main
	//========================================================================

	int main(int argc, char* argv[])
	{
	GLFWwindow* window;
	double t, dt_total, t_old;
	int width, height;

	glfwSetErrorCallback(error_callback);

	if (!glfwInit())
	exit(EXIT_FAILURE);

	window = glfwCreateWindow(640, 480, "Wave Simulation", NULL, NULL);
	if (!window)
	{
	glfwTerminate();
	exit(EXIT_FAILURE);
	}

	glfwSetKeyCallback(window, key_callback);
	glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);
	glfwSetMouseButtonCallback(window, mouse_button_callback);
	glfwSetCursorPosCallback(window, cursor_position_callback);
	glfwSetScrollCallback(window, scroll_callback);

	glfwMakeContextCurrent(window);
	gladLoadGL(glfwGetProcAddress);
	glfwSwapInterval(1);

	glfwGetFramebufferSize(window, &width, &height);
	framebuffer_size_callback(window, width, height);

	// Initialize OpenGL
	init_opengl();

	// Initialize simulation
	init_vertices();
	init_grid();
	adjust_grid();

	// Initialize timer
	t_old = glfwGetTime() - 0.01;

	while (!glfwWindowShouldClose(window))
	{
	t = glfwGetTime();
	dt_total = t - t_old;
	t_old = t;

	// Safety - iterate if dt_total is too large
	while (dt_total > 0.f)
	{
	// Select iteration time step
	dt = dt_total > MAX_DELTA_T ? MAX_DELTA_T : dt_total;
	dt_total -= dt;

	// Calculate wave propagation
	calc_grid();
	}

	// Compute height of each vertex
	adjust_grid();

	// Draw wave grid to OpenGL display
	draw_scene(window);

	glfwPollEvents();
	}

	glfwTerminate();
	exit(EXIT_SUCCESS);
	}