Beispiel #1
0
water::water()
  : material_(float4(0.4f, 0.4f, 0.4f, 1.0f),
							float4(0.1f, 0.1f, 0.1f, 1.0f),
							float4(0.6f, 0.6f, 0.6f, 1.0f),
							0.9f) {
  render_prog_ = ShaderProgram("Water.vert", "Water.frag");
  sim_prog_ = ShaderProgram("Quad.vert", "WaterSimStep.frag");
  normal_prog_ = ShaderProgram("Quad.vert", "WaterNormal.frag");

  water_mesh_ = new SimpleMesh(render_prog_.program, 256, SimpleMesh::PLANE, 0.999999f);
  
  full_screen_quad_ = new FullScreenQuad();

  grid_size_x_ = 256;
  grid_size_z_ = 256;

  for(int i = 0; i < 3; i++)
    pos_tex_[i] = new RenderableTexture2D(GL_R32F, grid_size_x_, grid_size_z_);

	norm_tex_ = new RenderableTexture2D(GL_RGB16F, grid_size_x_, grid_size_z_);
  a_ = 0; 
  b_ = 1; 
  c_ = 2;

  GLint old_viewport[4];
  glGetIntegerv(GL_VIEWPORT, old_viewport);
  glViewport(0, 0, grid_size_x_, grid_size_z_);
  
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  for(int i = 0; i < 3; i++) {
    pos_tex_[i]->BeginRenderingToThisTexture();
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    pos_tex_[i]->EndRenderingToThisTexture();
  }
	norm_tex_->BeginRenderingToThisTexture();
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
  norm_tex_->EndRenderingToThisTexture();


  glViewport(old_viewport[0], old_viewport[1], old_viewport[2], old_viewport[3]);

	float4x4 rotation_matrix, scale_matrix, translate_matrix;
  float4x4 transform_matrix1;

  glusScalef(scale_matrix.L(), 10, 10, 10);
  glusTranslatef(translate_matrix.L(), 0,0,0);
  glusMultMatrixf(object_matrix_.L(), translate_matrix.L(), scale_matrix.L());
	//glusMultMatrixf(object_matrix_.L(), scale_matrix.L(), translate_matrix.L());

	glusInverseMatrixf(inversed_object_matrix_.L(), object_matrix_.L());
}
Beispiel #2
0
void pool::init_object_matrix(int num_obj, GLfloat scale_coeff_x, GLfloat scale_coeff_y, GLfloat scale_coeff_z,
                              GLfloat translate_coeff_x, GLfloat translate_coeff_y, GLfloat translate_coeff_z,
                              GLfloat rotate_coeff_x, GLfloat rotate_coeff_z) {
    float4x4 rotationMatrix, scaleMatrix, translateMatrix;
    float4x4 transformMatrix1, transformMatrix2;

    glusRotateRzRyRxf(rotationMatrix.L(), rotate_coeff_x, 0.0f, rotate_coeff_z);
    glusScalef(scaleMatrix.L(), scale_coeff_x, scale_coeff_y, scale_coeff_z);
    glusTranslatef(translateMatrix.L(), translate_coeff_x, translate_coeff_y, translate_coeff_z);
    glusMultMatrixf(transformMatrix1.L(), rotationMatrix.L(), scaleMatrix.L());
    glusMultMatrixf(object_matrix_[num_obj].L(), translateMatrix.L(), transformMatrix1.L());
    glusInverseMatrixf(inversed_object_matrix_[num_obj].L(), object_matrix_[num_obj].L());

    size_x_[num_obj] = (int) scale_coeff_x;
    size_z_[num_obj] = (int) scale_coeff_z;
}
Beispiel #3
0
/**
 * Function to render and display content.
 */
GLUSboolean update(GLUSfloat time)
{
	// Angle for rotation
	static GLfloat angle = 0.0f;

	// Matrix for the model
	GLfloat model[16];

	// http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/clear.html
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Calculate the model matrix ...
	glusLoadIdentityf(model);
	glusRotateRzRyRxf(model, 45.0f, angle, 0.0f);
	// ... and the view matrix ...
	glusLookAtf(g_modelView, 0.0f, 0.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	glusCopyMatrixf(g_inverseCamera, g_modelView, GLUS_TRUE);
	glusInverseMatrixf(g_inverseCamera, g_inverseCamera);

	// ... to get the final model view matrix
	glusMultMatrixf(g_modelView, g_modelView, model);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniformMatrix4fv(g_modelViewLocation, 1, GL_FALSE, g_modelView);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniformMatrix4fv(g_inverseCameraLocation, 1, GL_FALSE, g_inverseCamera);

	// http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml
	glDrawElements(GL_TRIANGLES, 6 * 2 * 3, GL_UNSIGNED_INT, 0);

	angle += 20.0f * time;

	return GLUS_TRUE;
}
Beispiel #4
0
/**
 * Renders the water
 */
GLUSvoid renderWater(GLUSfloat passedTime, GLUSfloat angle)
{
	static WaveParameters waveParameters[NUMBERWAVES];
	static WaveDirections waveDirections[NUMBERWAVES];

	static GLfloat overallSteepness = 0.2f;

	GLfloat model[16];

	// Calculate the model matrix ...
	glusLoadIdentityf(model);
	// ... and the view matrix ...
	glusLookAtf(g_modelView, 0.0f, 1.0f, 0.0f, (GLfloat)0.5f * sinf(angle), 1.0f, -(GLfloat)0.5f * cosf(angle), 0.0f, 1.0f, 0.0f);
	// ... to get the final model view matrix
	glusMultMatrixf(g_modelView, g_modelView, model);

	// Copy the original view matrix ...
	glusCopyMatrixf(g_inverseCamera, g_modelView, GLUS_TRUE);
	// ... and inverse it
	glusInverseMatrixf(g_inverseCamera, g_inverseCamera);

	memset(waveParameters, 0, sizeof(waveParameters));
	memset(waveDirections, 0, sizeof(waveDirections));

	// Waves can be faded in and out.

	// Wave One
	waveParameters[0].speed = 1.0f;
	waveParameters[0].amplitude = 0.01f;
	waveParameters[0].wavelength = 4.0f;
	waveParameters[0].steepness = overallSteepness/(waveParameters[0].wavelength*waveParameters[0].amplitude*(GLfloat)NUMBERWAVES);
	waveDirections[0].x = +1.0f;
	waveDirections[0].z = +1.0f;

	// Wave Two
	waveParameters[1].speed = 0.5f;
	waveParameters[1].amplitude = 0.02f;
	waveParameters[1].wavelength = 3.0f;
	waveParameters[1].steepness = overallSteepness/(waveParameters[1].wavelength*waveParameters[1].amplitude*(GLfloat)NUMBERWAVES);
	waveDirections[1].x = +1.0f;
	waveDirections[1].z = +0.0f;

	// Wave Thre
	waveParameters[2].speed = 0.1f;
	waveParameters[2].amplitude = 0.015f;
	waveParameters[2].wavelength = 2.0f;
	waveParameters[2].steepness = overallSteepness/(waveParameters[1].wavelength*waveParameters[1].amplitude*(GLfloat)NUMBERWAVES);
	waveDirections[2].x = -0.1f;
	waveDirections[2].z = -0.2f;

	// Wave Four
	waveParameters[3].speed = 1.1f;
	waveParameters[3].amplitude = 0.008f;
	waveParameters[3].wavelength = 1.0f;
	waveParameters[3].steepness = overallSteepness/(waveParameters[1].wavelength*waveParameters[1].amplitude*(GLfloat)NUMBERWAVES);
	waveDirections[3].x = -0.2f;
	waveDirections[3].z = -0.1f;

	// http://www.opengl.org/sdk/docs/man/xhtml/glUseProgram.xml
	glUseProgram(g_program.program);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniformMatrix4fv(g_modelViewLocation, 1, GL_FALSE, g_modelView);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniformMatrix4fv(g_inverseCameraLocation, 1, GL_FALSE, g_inverseCamera);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniform1f(g_passedTimeLocation, passedTime);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniform4fv(g_waveParametersLocation, 4*NUMBERWAVES, (GLfloat*)waveParameters);

	// http://www.opengl.org/sdk/docs/man/xhtml/glUniform.xml
	glUniform2fv(g_waveDirectionsLocation, 2*NUMBERWAVES, (GLfloat*)waveDirections);

	// ToDo:
	glBindVertexArray(g_vao);

	// ToDo:
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);

	//http://www.opengl.org/documentation/specs/man_pages/hardcopy/GL/html/gl/disable.html
	glDisable(GL_CULL_FACE);

	// http://www.opengl.org/sdk/docs/man/xhtml/glDrawElements.xml
	glDrawElements(GL_TRIANGLE_STRIP, WATER_PLANE_LENGTH*(WATER_PLANE_LENGTH-1)*2, GL_UNSIGNED_INT, 0);
}