void FurApplication::Display(bool auto_redraw)
{
float t = float(GetTickCount() & 0x3FFF) / float(0x3FFF);
static const vmath::vec3 X(1.0f, 0.0f, 0.0f);
static const vmath::vec3 Y(0.0f, 1.0f, 0.0f);
static const vmath::vec3 Z(0.0f, 0.0f, 1.0f);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
vmath::mat4 p(vmath::frustum(-1.0f, 1.0f, aspect, -aspect, 1.0f, 5000.0f));
vmath::mat4 m;
m = vmath::mat4(vmath::translate(0.0f,
0.0f,
/* 100.0f * sinf(6.28318531f * t)*/ - 150.0f) *
//vmath::rotation(360.0f * t, X) *
vmath::rotate(360.0f * t * 1.0f, Y) *
vmath::rotate(180.0f, Z) *
vmath::translate(0.0f, -80.0f, 0.0f));
glUseProgram(base_prog);
glUniformMatrix4fv(base_model_matrix_pos, 1, GL_FALSE, m[0]);
glUniformMatrix4fv(base_projection_matrix_pos, 1, GL_FALSE, p);
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
object.Render();
glUseProgram(fur_prog);
glUniformMatrix4fv(fur_model_matrix_pos, 1, GL_FALSE, m[0]);
glUniformMatrix4fv(fur_projection_matrix_pos, 1, GL_FALSE, p);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
object.Render();
glDepthMask(GL_TRUE);
glDisable(GL_BLEND);
base::Display();
}
void ShadowMapExample::DrawScene(bool depth_only)
{
// Set material properties for the object
if (!depth_only)
{
glUniform3fv(render_scene_uniforms.material_ambient, 1, vec3(0.1f, 0.0f, 0.2f));
glUniform3fv(render_scene_uniforms.material_diffuse, 1, vec3(0.3f, 0.2f, 0.8f));
glUniform3fv(render_scene_uniforms.material_specular, 1, vec3(1.0f, 1.0f, 1.0f));
glUniform1f(render_scene_uniforms.material_specular_power, 25.0f);
}
// Draw the object
object.Render();
// Set material properties for the ground
if (!depth_only)
{
glUniform3fv(render_scene_uniforms.material_ambient, 1, vec3(0.1f, 0.1f, 0.1f));
glUniform3fv(render_scene_uniforms.material_diffuse, 1, vec3(0.1f, 0.5f, 0.1f));
glUniform3fv(render_scene_uniforms.material_specular, 1, vec3(0.1f, 0.1f, 0.1f));
glUniform1f(render_scene_uniforms.material_specular_power, 3.0f);
}
// Draw the ground
glBindVertexArray(ground_vao);
glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
glBindVertexArray(0);
}
void LightingExample::Display(bool auto_redraw)
{
float time = 0.5f; // float(GetTickCount() & 0xFFFF) / float(0xFFFF);
vmath::mat4 mv_matrix = vmath::translate(0.0f, 0.0f, -4.0f) *
vmath::rotate(987.0f * time * 3.14159f, vmath::vec3(0.0f, 0.0f, 1.0f)) *
vmath::rotate(1234.0f * time * 3.14159f, vmath::vec3(1.0f, 0.0f, 0.0f));
vmath::mat4 prj_matrix = vmath::perspective(60.0f, 1.333f, 0.1f, 1000.0f);
glUseProgram(render_prog);
glUniformMatrix4fv(mv_mat_loc, 1, GL_FALSE, mv_matrix);
glUniformMatrix4fv(prj_mat_loc, 1, GL_FALSE, prj_matrix);
// Clear, select the rendering program and draw a full screen quad
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
object.Render();
base::Display();
}
void FurApplication::Initialize(const char * title)
{
base::Initialize(title);
static ShaderInfo shader_info[] =
{
{ GL_VERTEX_SHADER, "base_vs.glsl" },
{ GL_FRAGMENT_SHADER, "base_fs.glsl" },
{ GL_NONE, NULL }
};
base_prog = LoadShaders(shader_info);
glUseProgram(base_prog);
base_model_matrix_pos = glGetUniformLocation(base_prog, "model_matrix");
base_projection_matrix_pos = glGetUniformLocation(base_prog, "projection_matrix");
static ShaderInfo shader_info2[] =
{
{ GL_VERTEX_SHADER, "fur_vs.glsl" },
{ GL_GEOMETRY_SHADER, "fur_gs.glsl" },
{ GL_FRAGMENT_SHADER, "fur_fs.glsl" },
{ GL_NONE, NULL }
};
fur_prog = LoadShaders(shader_info2);
glUseProgram(fur_prog);
fur_model_matrix_pos = glGetUniformLocation(fur_prog, "model_matrix");
fur_projection_matrix_pos = glGetUniformLocation(fur_prog, "projection_matrix");
glGenTextures(1, &fur_texture);
unsigned char * tex = (unsigned char *)malloc(1024 * 1024 * 4);
memset(tex, 0, 1024 * 1024 * 4);
int n, m;
for (n = 0; n < 256; n++)
{
for (m = 0; m < 1270; m++)
{
int x = rand() & 0x3FF;
int y = rand() & 0x3FF;
tex[(y * 1024 + x) * 4 + 0] = n;//(rand() & 0x3F) + 0xC0;
tex[(y * 1024 + x) * 4 + 1] = n;//(rand() & 0x3F) + 0xC0;
tex[(y * 1024 + x) * 4 + 2] = n;//(rand() & 0x3F) + 0xC0;
tex[(y * 1024 + x) * 4 + 3] = n;
}
}
glBindTexture(GL_TEXTURE_2D, fur_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
free(tex);
//object.LoadFromVBM("F:/tzpRepository/opengl/oglpg-8th-edition/media/unit_cube.vbm", 0, 1, 2);
object.LoadFromVBM("F:/tzpRepository/opengl/oglpg-8th-edition/media/ninja.vbm", 0, 1, 2);
}
void ImageApp::init_buffer()
{
render_scene_prog = -1;
// Create palette texture
glGenBuffers(1, &image_palette_buffer);
glBindBuffer(GL_TEXTURE_BUFFER, image_palette_buffer);
glBufferData(GL_TEXTURE_BUFFER, 256 * 4 * sizeof(float), NULL, GL_STATIC_DRAW);
glGenTextures(1, &image_palette_texture);
glBindTexture(GL_TEXTURE_BUFFER, image_palette_texture);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, image_palette_buffer);
vmath::vec4 * data = (vmath::vec4 *)glMapBuffer(GL_TEXTURE_BUFFER, GL_WRITE_ONLY);
for (int i = 0; i < 256; i++)
{
data[i] = vmath::vec4((float)i);
}
glUnmapBuffer(GL_TEXTURE_BUFFER);
// Create overdraw counter texture
glGenTextures(1, &overdraw_count_buffer);
glBindTexture(GL_TEXTURE_2D, overdraw_count_buffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexImage2D(GL_TEXTURE_2D, 0, GL_R32UI, MAX_FRAMEBUFFER_WIDTH, MAX_FRAMEBUFFER_HEIGHT, 0, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
// Create buffer for clearing the head pointer texture
glGenBuffers(1, &overdraw_count_clear_buffer);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, overdraw_count_clear_buffer);
glBufferData(GL_PIXEL_UNPACK_BUFFER, MAX_FRAMEBUFFER_WIDTH * MAX_FRAMEBUFFER_HEIGHT * sizeof(GLuint), NULL, GL_STATIC_DRAW);
data = (vmath::vec4 *)glMapBuffer(GL_PIXEL_UNPACK_BUFFER, GL_WRITE_ONLY);
memset(data, 0x00, MAX_FRAMEBUFFER_WIDTH * MAX_FRAMEBUFFER_HEIGHT * sizeof(GLuint));
glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
// Create VAO containing quad for the final blit
glGenVertexArrays(1, &quad_vao);
glBindVertexArray(quad_vao);
static const GLfloat quad_verts[] =
{
-1.0f, -1.0f,
1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, 1.0f,
};
glGenBuffers(1, &quad_vbo);
glBindBuffer(GL_ARRAY_BUFFER, quad_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(quad_verts), quad_verts, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);
glClearDepth(1.0f);
object.LoadFromVBM("../../../media/objects/unit_pipe.vbm", 0, 1, 2);
}
void InstancingExample::Display(bool auto_redraw)
{
float t = float(GetTickCount() & 0x3FFF) / float(0x3FFF);
static float q = 0.0f;
static const vec3 X(1.0f, 0.0f, 0.0f);
static const vec3 Y(0.0f, 1.0f, 0.0f);
static const vec3 Z(0.0f, 0.0f, 1.0f);
int n;
// Clear
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Setup
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// Bind the weight VBO and change its data
glBindBuffer(GL_ARRAY_BUFFER, model_matrix_buffer);
// Set model matrices for each instance
mat4 * matrices = (mat4 *)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
for (n = 0; n < INSTANCE_COUNT; n++)
{
float a = 50.0f * float(n) / 4.0f;
float b = 50.0f * float(n) / 5.0f;
float c = 50.0f * float(n) / 6.0f;
matrices[n] = rotate(a + t * 360.0f, 1.0f, 0.0f, 0.0f) *
rotate(b + t * 360.0f, 0.0f, 1.0f, 0.0f) *
rotate(c + t * 360.0f, 0.0f, 0.0f, 1.0f) *
translate(10.0f + a, 40.0f + b, 50.0f + c);
}
glUnmapBuffer(GL_ARRAY_BUFFER);
// Activate instancing program
glUseProgram(render_prog);
// Set up the view and projection matrices
mat4 view_matrix(translate(0.0f, 0.0f, -1500.0f) * rotate(t * 360.0f * 2.0f, 0.0f, 1.0f, 0.0f));
mat4 projection_matrix(frustum(-1.0f, 1.0f, -aspect, aspect, 1.0f, 5000.0f));
glUniformMatrix4fv(view_matrix_loc, 1, GL_FALSE, view_matrix);
glUniformMatrix4fv(projection_matrix_loc, 1, GL_FALSE, projection_matrix);
// Render INSTANCE_COUNT objects
object.Render(0, INSTANCE_COUNT);
lookat(vec3(0.0f, 0.0f, 0.0f), vec3(1.0f, 0.0f, 0.0f), vec3(0.0f, 1.0f, 0.0f));
base::Display();
}
void CubeMapExample::Display(bool auto_redraw)
{
static const unsigned int start_time = GetTickCount();
float t = float((GetTickCount() - start_time)) / float(0x3FFF);
static const vmath::vec3 X(1.0f, 0.0f, 0.0f);
static const vmath::vec3 Y(0.0f, 1.0f, 0.0f);
static const vmath::vec3 Z(0.0f, 0.0f, 1.0f);
vmath::mat4 tc_matrix(vmath::mat4::identity());
glClearColor(0.0f, 0.25f, 0.3f, 1.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glDisable(GL_CULL_FACE);
//调用天空盒映射着色器程序
glUseProgram(skybox_prog);
//GL_TEXTURE_CUBE_MAP_SEAMLESS启用无缝立方体映射滤波，避免立方体映射相邻边之间的缝
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
tc_matrix = vmath::rotate(80.0f * 3.0f * t, Y);// * vmath::rotate(22.0f, Z);
tc_matrix = vmath::perspective(35.0f, 1.0f / aspect, 0.1f, 100.0f) * tc_matrix;
glUniformMatrix4fv(skybox_rotate_loc, 1, GL_FALSE, tc_matrix);
glBindVertexArray(vao);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cube_element_buffer);
//绘制天空盒，完成立方体映射
glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_SHORT, NULL);
glDrawElements(GL_TRIANGLE_STRIP, 8, GL_UNSIGNED_SHORT, BUFFER_OFFSET(8 * sizeof(GLushort)));
//调用环境映射着色器程序
glUseProgram(object_prog);
tc_matrix = vmath::translate(vmath::vec3(0.0f, 0.0f, -4.0f)) *
vmath::rotate(80.0f * 3.0f * t, Y) * vmath::rotate(70.0f * 3.0f * t, Z);
glUniformMatrix4fv(object_mat_mv_loc, 1, GL_FALSE, tc_matrix);
tc_matrix = vmath::perspective(35.0f, 1.0f / aspect, 0.1f, 100.0f) * tc_matrix;
glUniformMatrix4fv(object_mat_mvp_loc, 1, GL_FALSE, tc_matrix);
glClear(GL_DEPTH_BUFFER_BIT);
//绘制物体，完成环境映射
object.Render();
base::Display();
}
void OverdrawCountExample::Display(bool auto_redraw)
{
float t;
unsigned int current_time = GetTickCount();
t = (float)(current_time & 0xFFFFF) / (float)0x3FFF;
glDisable(GL_DEPTH_TEST);
glDisable(GL_CULL_FACE);
glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);
// Clear output image
glBindBuffer(GL_PIXEL_UNPACK_BUFFER, overdraw_count_clear_buffer);
glBindTexture(GL_TEXTURE_2D, overdraw_count_buffer);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, current_width, current_height, GL_RED_INTEGER, GL_UNSIGNED_INT, NULL);
glBindTexture(GL_TEXTURE_2D, 0);
// Bind output image for read-write
glBindImageTexture(0, overdraw_count_buffer, 0, GL_FALSE, 0, GL_READ_WRITE, GL_R32UI);
// Render
glUseProgram(render_scene_prog);
vmath::mat4 model_matrix = vmath::translate(0.0f, 0.0f, -20.0f) *
vmath::rotate(t * 360.0f, 0.0f, 0.0f, 1.0f) *
vmath::rotate(t * 435.0f, 0.0f, 1.0f, 0.0f) *
vmath::rotate(t * 275.0f, 1.0f, 0.0f, 0.0f);
vmath::mat4 view_matrix = vmath::mat4::identity();
vmath::mat4 projection_matrix = vmath::frustum(-1.0f, 1.0f, aspect, -aspect, 1.0f, 40.f);
glUniformMatrix4fv(render_scene_uniforms.model_matrix, 1, GL_FALSE, model_matrix);
glUniformMatrix4fv(render_scene_uniforms.view_matrix, 1, GL_FALSE, view_matrix);
glUniformMatrix4fv(render_scene_uniforms.projection_matrix, 1, GL_FALSE, projection_matrix);
glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);
object.Render(0, 8 * 8 * 8);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glBindVertexArray(quad_vao);
glUseProgram(resolve_program);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
// Done
base::Display();
}
void Init(void)
{
ShaderInfo shaders[] = {
{ GL_VERTEX_SHADER, "light_model.vert" },
{ GL_FRAGMENT_SHADER, "light_model.frag" },
{ GL_NONE, NULL}
};
light_prog = LoadShaders(shaders);
model_mat_loc = glGetUniformLocation(light_prog, "model_matrix");
proj_mat_loc = glGetUniformLocation(light_prog, "proj_matrix");
color_ambient_loc = glGetUniformLocation(light_prog, "color_ambient");
color_diffuse_loc = glGetUniformLocation(light_prog, "color_diffuse");
color_specular_loc = glGetUniformLocation(light_prog, "color_specular");
shininess_loc = glGetUniformLocation(light_prog, "shininess");
light_pos_loc = glGetUniformLocation(light_prog, "light_position");
object.LoadFromVBM("../../media/unit_torus.vbm", 0, 1, 2);
}
void DisplayFunc(void)
{
float time = float(GetTickCount() & 0xFFFF) / float(0xFFFF);
vmath::mat4 model_matrix = vmath::translate(0.0f, 0.0f, -4.0f) *
vmath::rotate(987.0f * time * 3.141592f, vmath::vec3(0.0f, 0.0f, 1.0f)) *
vmath::rotate(1234.0f *time * 3.141592f, vmath::vec3(1.0f, 0.0f, 0.0f));
vmath::mat4 proj_matrix = vmath::perspective(60.0f, 1.333, 0.1f, 1000.0f);
glUseProgram(light_prog);
glUniformMatrix4fv(model_mat_loc, 1, GL_FALSE, model_matrix);
glUniformMatrix4fv(proj_mat_loc, 1, GL_FALSE, proj_matrix);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glCullFace(GL_BACK);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
object.Render();
glutPostRedisplay();
}
void InstancingExample::Initialize(const char * title)
{
int n;
base::Initialize(title);
// Create the program for rendering the model
render_prog = glCreateProgram();
// This is the rendering vertex shader
static const char render_vs[] =
"#version 330\n"
"\n"
"// 'position' and 'normal' are regular vertex attributes\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"// Color is a per-instance attribute\n"
"layout (location = 2) in vec4 color;\n"
"\n"
"// model_matrix will be used as a per-instance transformation\n"
"// matrix. Note that a mat4 consumes 4 consecutive locations, so\n"
"// this will actually sit in locations, 3, 4, 5, and 6.\n"
"layout (location = 3) in mat4 model_matrix;\n"
"\n"
"// The view matrix and the projection matrix are constant across a draw\n"
"uniform mat4 view_matrix;\n"
"uniform mat4 projection_matrix;\n"
"\n"
"// The output of the vertex shader (matched to the fragment shader)\n"
"out VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec4 color;\n"
"} vertex;\n"
"\n"
"// Ok, go!\n"
"void main(void)\n"
"{\n"
" // Construct a model-view matrix from the uniform view matrix\n"
" // and the per-instance model matrix.\n"
" mat4 model_view_matrix = view_matrix * model_matrix;\n"
"\n"
" // Transform position by the model-view matrix, then by the\n"
" // projection matrix.\n"
" gl_Position = projection_matrix * (model_view_matrix * position);\n"
" // Transform the normal by the upper-left-3x3-submatrix of the\n"
" // model-view matrix\n"
" vertex.normal = mat3(model_view_matrix) * normal;\n"
" // Pass the per-instance color through to the fragment shader.\n"
" vertex.color = color;\n"
"}\n";
// Simple fragment shader
static const char render_fs[] =
"#version 330\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"in VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec4 color;\n"
"} vertex;\n"
"\n"
"void main(void)\n"
"{\n"
" color = vertex.color * (0.1 + abs(vertex.normal.z)) + vec4(0.8, 0.9, 0.7, 1.0) * pow(abs(vertex.normal.z), 40.0);\n"
"}\n";
// Compile and link like normal
vglAttachShaderSource(render_prog, GL_VERTEX_SHADER, render_vs);
vglAttachShaderSource(render_prog, GL_FRAGMENT_SHADER, render_fs);
glLinkProgram(render_prog);
glUseProgram(render_prog);
// Get the location of the projetion_matrix uniform
view_matrix_loc = glGetUniformLocation(render_prog, "view_matrix");
projection_matrix_loc = glGetUniformLocation(render_prog, "projection_matrix");
// Load the object
object.LoadFromVBM("../../media/armadillo_low.vbm", 0, 1, 2);
// Bind its vertex array object so that we can append the instanced attributes
object.BindVertexArray();
// Get the locations of the vertex attributes in 'prog', which is the
// (linked) program object that we're going to be rendering with. Note
// that this isn't really necessary because we specified locations for
// all the attributes in our vertex shader. This code could be made
// more concise by assuming the vertex attributes are where we asked
// the compiler to put them.
int position_loc = glGetAttribLocation(render_prog, "position");
int normal_loc = glGetAttribLocation(render_prog, "normal");
int color_loc = glGetAttribLocation(render_prog, "color");
int matrix_loc = glGetAttribLocation(render_prog, "model_matrix");
// Configure the regular vertex attribute arrays - position and color.
/*
// This is commented out here because the VBM object takes care
// of it for us.
glBindBuffer(GL_ARRAY_BUFFER, position_buffer);
glVertexAttribPointer(position_loc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(position_loc);
glBindBuffer(GL_ARRAY_BUFFER, normal_buffer);
glVertexAttribPointer(normal_loc, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(normal_loc);
*/
// Generate the colors of the objects
vec4 colors[INSTANCE_COUNT];
for (n = 0; n < INSTANCE_COUNT; n++)
{
float a = float(n) / 4.0f;
float b = float(n) / 5.0f;
float c = float(n) / 6.0f;
colors[n][0] = 0.5f + 0.25f * (sinf(a + 1.0f) + 1.0f);
colors[n][1] = 0.5f + 0.25f * (sinf(b + 2.0f) + 1.0f);
colors[n][2] = 0.5f + 0.25f * (sinf(c + 3.0f) + 1.0f);
colors[n][3] = 1.0f;
}
glGenBuffers(1, &color_buffer);
glBindBuffer(GL_ARRAY_BUFFER, color_buffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors, GL_DYNAMIC_DRAW);
// Now we set up the color array. We want each instance of our geometry
// to assume a different color, so we'll just pack colors into a buffer
// object and make an instanced vertex attribute out of it.
glBindBuffer(GL_ARRAY_BUFFER, color_buffer);
glVertexAttribPointer(color_loc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(color_loc);
// This is the important bit... set the divisor for the color array to
// 1 to get OpenGL to give us a new value of 'color' per-instance
// rather than per-vertex.
glVertexAttribDivisor(color_loc, 1);
// Likewise, we can do the same with the model matrix. Note that a
// matrix input to the vertex shader consumes N consecutive input
// locations, where N is the number of columns in the matrix. So...
// we have four vertex attributes to set up.
glGenBuffers(1, &model_matrix_buffer);
glBindBuffer(GL_ARRAY_BUFFER, model_matrix_buffer);
glBufferData(GL_ARRAY_BUFFER, INSTANCE_COUNT * sizeof(mat4), NULL, GL_DYNAMIC_DRAW);
// Loop over each column of the matrix...
for (int i = 0; i < 4; i++)
{
// Set up the vertex attribute
glVertexAttribPointer(matrix_loc + i, // Location
4, GL_FLOAT, GL_FALSE, // vec4
sizeof(mat4), // Stride
(void *)(sizeof(vec4) * i)); // Start offset
// Enable it
glEnableVertexAttribArray(matrix_loc + i);
// Make it instanced
glVertexAttribDivisor(matrix_loc + i, 1);
}
// Done (unbind the object's VAO)
glBindVertexArray(0);
}
void ShadowMapExample::Initialize(const char * title)
{
base::Initialize(title);
// Create the program for rendering the scene from the light's POV.
glCreateProgram();
ShaderInfo light_shaders[] =
{
{ GL_VERTEX_SHADER, "shadowmap_shadow.vs.glsl" },
{ GL_FRAGMENT_SHADER, "shadowmap_shadow.fs.glsl" },
{ GL_NONE }
};
render_light_prog = LoadShaders(light_shaders);
// Get the location of the projetion_matrix uniform
render_light_uniforms.model_view_projection_matrix = glGetUniformLocation(render_light_prog, "model_view_projection_matrix");
// Create the program for rendering the scene from the viewer's position
ShaderInfo scene_shaders[] =
{
{ GL_VERTEX_SHADER, "shadowmap_scene.vs.glsl" },
{ GL_FRAGMENT_SHADER, "shadowmap_scene.fs.glsl" },
{ GL_NONE }
};
render_scene_prog = LoadShaders(scene_shaders);
// Get the locations of all the uniforms in the program
render_scene_uniforms.model_matrix = glGetUniformLocation(render_scene_prog, "model_matrix");
render_scene_uniforms.view_matrix = glGetUniformLocation(render_scene_prog, "view_matrix");
render_scene_uniforms.projection_matrix = glGetUniformLocation(render_scene_prog, "projection_matrix");
render_scene_uniforms.shadow_matrix = glGetUniformLocation(render_scene_prog, "shadow_matrix");
render_scene_uniforms.light_position = glGetUniformLocation(render_scene_prog, "light_position");
render_scene_uniforms.material_ambient = glGetUniformLocation(render_scene_prog, "material_ambient");
render_scene_uniforms.material_diffuse = glGetUniformLocation(render_scene_prog, "material_diffuse");
render_scene_uniforms.material_specular = glGetUniformLocation(render_scene_prog, "material_specular");
render_scene_uniforms.material_specular_power = glGetUniformLocation(render_scene_prog, "material_specular_power");
// Set the depth texture uniform to unit 0
glUseProgram(render_scene_prog);
glUniform1i(glGetUniformLocation(render_scene_prog, "depth_texture"), 0);
// Create a depth texture
glGenTextures(1, &depth_texture);
glBindTexture(GL_TEXTURE_2D, depth_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, DEPTH_TEXTURE_SIZE, DEPTH_TEXTURE_SIZE, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
// Create FBO to render depth into
glGenFramebuffers(1, &depth_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, depth_fbo);
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, depth_texture, 0);
glDrawBuffer(GL_NONE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Upload geometry for the ground plane
static const float ground_vertices[] =
{
-500.0f, -50.0f, -500.0f, 1.0f,
-500.0f, -50.0f, 500.0f, 1.0f,
500.0f, -50.0f, 500.0f, 1.0f,
500.0f, -50.0f, -500.0f, 1.0f,
};
static const float ground_normals[] =
{
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f
};
glGenVertexArrays(1, &ground_vao);
glGenBuffers(1, &ground_vbo);
glBindVertexArray(ground_vao);
glBindBuffer(GL_ARRAY_BUFFER, ground_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(ground_vertices) + sizeof(ground_normals), NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(ground_vertices), ground_vertices);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(ground_vertices), sizeof(ground_normals), ground_normals);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)sizeof(ground_vertices));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
// Load the object
object.LoadFromVBM("C:/Vermilion-Book/trunk/Code/media/armadillo_low.vbm", 0, 1, 2);
}
void FurApplication::Initialize(const char * title)
{
base::Initialize(title);
base_prog = glCreateProgram();
static const char base_vs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) in vec4 position_in;\n"
"layout (location = 1) in vec3 normal_in;\n"
"layout (location = 2) in vec2 texcoord_in;\n"
"\n"
"uniform mat4 model_matrix;\n"
"uniform mat4 projection_matrix;\n"
"\n"
"out VS_FS_VERTEX\n"
"{\n"
" vec3 normal;\n"
"} vertex_out;\n"
"\n"
"void main(void)\n"
"{\n"
" vertex_out.normal = normal_in;\n"
" gl_Position = projection_matrix * (model_matrix * position_in);\n"
"}\n";
static const char base_fs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"in VS_FS_VERTEX\n"
"{\n"
" vec3 normal;\n"
"} vertex_in;\n"
"\n"
"void main(void)\n"
"{\n"
" vec3 normal = vertex_in.normal;\n"
" color = vec4(0.2, 0.1, 0.5, 1.0) * (0.2 + pow(abs(normal.z), 4.0)) + vec4(0.8, 0.8, 0.8, 0.0) * pow(abs(normal.z), 137.0);\n"
"}\n";
vglAttachShaderSource(base_prog, GL_VERTEX_SHADER, base_vs_source);
vglAttachShaderSource(base_prog, GL_FRAGMENT_SHADER, base_fs_source);
glLinkProgram(base_prog);
glUseProgram(base_prog);
base_model_matrix_pos = glGetUniformLocation(base_prog, "model_matrix");
base_projection_matrix_pos = glGetUniformLocation(base_prog, "projection_matrix");
fur_prog = glCreateProgram();
static const char fur_vs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) in vec4 position_in;\n"
"layout (location = 1) in vec3 normal_in;\n"
"layout (location = 2) in vec2 texcoord_in;\n"
"\n"
"out VS_GS_VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec2 tex_coord;\n"
"} vertex_out;\n"
"\n"
"void main(void)\n"
"{\n"
" vertex_out.normal = normal_in;\n"
" vertex_out.tex_coord = texcoord_in;\n"
" gl_Position = position_in;\n"
"}\n";
static const char fur_gs_source[] =
"#version 410\n"
"\n"
"layout (triangles) in;\n"
"layout (triangle_strip, max_vertices = 240) out;\n"
"\n"
"uniform mat4 model_matrix;\n"
"uniform mat4 projection_matrix;\n"
"\n"
"uniform int fur_layers = 30;\n"
"uniform float fur_depth = 5.0;\n"
"\n"
"in VS_GS_VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec2 tex_coord;\n"
"} vertex_in[];\n"
"\n"
"out GS_FS_VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec2 tex_coord;\n"
" flat float fur_strength;\n"
"} vertex_out;\n"
"\n"
"void main(void)\n"
"{\n"
" int i, layer;\n"
" float disp_delta = 1.0 / float(fur_layers);\n"
" float d = 0.0;\n"
" vec4 position;\n"
"\n"
" for (layer = 0; layer < fur_layers; layer++)\n"
" {\n"
" for (i = 0; i < gl_in.length(); i++) {\n"
" vec3 n = vertex_in[i].normal;\n"
" vertex_out.normal = n;\n"
" vertex_out.tex_coord = vertex_in[i].tex_coord;\n"
" vertex_out.fur_strength = 1.0 - d;\n"
" position = gl_in[i].gl_Position + vec4(n * d * fur_depth, 0.0);\n"
" gl_Position = projection_matrix * (model_matrix * position);\n"
" EmitVertex();\n"
" }\n"
" d += disp_delta;\n"
" EndPrimitive();\n"
" }\n"
"}\n";
static const char fur_fs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"uniform sampler2D fur_texture;\n"
"uniform vec4 fur_color = vec4(0.8, 0.8, 0.9, 1.0);\n"
"\n"
"in GS_FS_VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec2 tex_coord;\n"
" flat float fur_strength;\n"
"} fragment_in;\n"
"\n"
"void main(void)\n"
"{\n"
" vec4 rgba = texture(fur_texture, fragment_in.tex_coord);\n"
" float t = rgba.a;\n"
" t *= fragment_in.fur_strength;\n"
" color = fur_color * vec4(1.0, 1.0, 1.0, t);\n"
"}\n";
vglAttachShaderSource(fur_prog, GL_VERTEX_SHADER, fur_vs_source);
vglAttachShaderSource(fur_prog, GL_GEOMETRY_SHADER, fur_gs_source);
vglAttachShaderSource(fur_prog, GL_FRAGMENT_SHADER, fur_fs_source);
glLinkProgram(fur_prog);
glUseProgram(fur_prog);
fur_model_matrix_pos = glGetUniformLocation(fur_prog, "model_matrix");
fur_projection_matrix_pos = glGetUniformLocation(fur_prog, "projection_matrix");
glGenTextures(1, &fur_texture);
unsigned char * tex = (unsigned char *)malloc(1024 * 1024 * 4);
memset(tex, 0, 1024 * 1024 * 4);
int n, m;
for (n = 0; n < 256; n++)
{
for (m = 0; m < 1270; m++)
{
int x = rand() & 0x3FF;
int y = rand() & 0x3FF;
tex[(y * 1024 + x) * 4 + 0] = (rand() & 0x3F) + 0xC0;
tex[(y * 1024 + x) * 4 + 1] = (rand() & 0x3F) + 0xC0;
tex[(y * 1024 + x) * 4 + 2] = (rand() & 0x3F) + 0xC0;
tex[(y * 1024 + x) * 4 + 3] = n;
}
}
glBindTexture(GL_TEXTURE_2D, fur_texture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 1024, 1024, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
free(tex);
object.LoadFromVBM("C:/Vermilion-Book/trunk/Code/media/ninja.vbm", 0, 1, 2);
}
void ViewportArrayApplication::Initialize(const char * title)
{
int i;
base::Initialize(title);
glGenTransformFeedbacks(1, &xfb);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb);
sort_prog = glCreateProgram();
static const char sort_vs_source[] =
"#version 410\n"
"\n"
"uniform mat4 model_matrix;\n"
"\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"out vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vs_normal = (model_matrix * vec4(normal, 0.0)).xyz;\n"
" gl_Position = model_matrix * position;\n"
"}\n";
static const char sort_gs_source[] =
"#version 410\n"
"\n"
"layout (triangles) in;\n"
"layout (points, max_vertices = 3) out;\n"
"\n"
"uniform mat4 projection_matrix;\n"
"\n"
"in vec3 vs_normal[];\n"
"\n"
"layout (stream = 0) out vec4 rf_position;\n"
"layout (stream = 0) out vec3 rf_normal;\n"
"\n"
"layout (stream = 1) out vec4 lf_position;\n"
"layout (stream = 1) out vec3 lf_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vec4 A = gl_in[0].gl_Position;\n"
" vec4 B = gl_in[1].gl_Position;\n"
" vec4 C = gl_in[2].gl_Position;\n"
" vec3 AB = (B - A).xyz;\n"
" vec3 AC = (C - A).xyz;\n"
" vec3 face_normal = cross(AB, AC);\n"
" int i;\n"
"\n"
" if (face_normal.x < 0.0)\n"
" {\n"
" for (i = 0; i < gl_in.length(); i++)\n"
" {\n"
" rf_position = projection_matrix * (gl_in[i].gl_Position - vec4(30.0, 0.0, 0.0, 0.0));\n"
" rf_normal = vs_normal[i];\n"
" EmitStreamVertex(0);\n"
" }\n"
" EndStreamPrimitive(0);\n"
" }\n"
" else\n"
" {\n"
" for (i = 0; i < gl_in.length(); i++)\n"
" {\n"
" lf_position = projection_matrix * (gl_in[i].gl_Position + vec4(30.0, 0.0, 0.0, 0.0));\n"
" lf_normal = vs_normal[i];\n"
" EmitStreamVertex(1);\n"
" }\n"
" EndStreamPrimitive(1);\n"
" }\n"
"}\n";
vglAttachShaderSource(sort_prog, GL_VERTEX_SHADER, sort_vs_source);
vglAttachShaderSource(sort_prog, GL_GEOMETRY_SHADER, sort_gs_source);
static const char * varyings[] =
{
"rf_position", "rf_normal",
"gl_NextBuffer",
"lf_position", "lf_normal"
};
glTransformFeedbackVaryings(sort_prog, 5, varyings, GL_INTERLEAVED_ATTRIBS);
glLinkProgram(sort_prog);
glUseProgram(sort_prog);
model_matrix_pos = glGetUniformLocation(sort_prog, "model_matrix");
projection_matrix_pos = glGetUniformLocation(sort_prog, "projection_matrix");
glGenVertexArrays(2, vao);
glGenBuffers(2, vbo);
for (i = 0; i < 2; i++)
{
glBindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, vbo[i]);
glBufferData(GL_TRANSFORM_FEEDBACK_BUFFER, 1024 * 1024 * sizeof(GLfloat), NULL, GL_DYNAMIC_COPY);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, i, vbo[i]);
glBindVertexArray(vao[i]);
glBindBuffer(GL_ARRAY_BUFFER, vbo[i]);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(vmath::vec4) + sizeof(vmath::vec3), NULL);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(vmath::vec4) + sizeof(vmath::vec3), (GLvoid *)(sizeof(vmath::vec4)));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
}
render_prog = glCreateProgram();
static const char render_vs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"out vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vs_normal = normal;\n"
" gl_Position = position;\n"
"}\n";
static const char render_fs_source[] =
"#version 410\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"uniform vec4 pass_color;\n"
"\n"
"in vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" color = pass_color * (0.2 + pow(abs(vs_normal.z), 4.0)) + vec4(1.0, 1.0, 1.0, 0.0) * pow(abs(vs_normal.z), 37.0);\n"
"}\n";
vglAttachShaderSource(render_prog, GL_VERTEX_SHADER, render_vs_source);
vglAttachShaderSource(render_prog, GL_FRAGMENT_SHADER, render_fs_source);
glLinkProgram(render_prog);
object.LoadFromVBM("D:/svn/Vermilion-Book/trunk/Code/media/ninja.vbm", 0, 1, 2);
}
void ViewportArrayApplication::Display(bool auto_redraw)
{
float t = float(GetTickCount() & 0x3FFF) / float(0x3FFF);
static const vmath::vec3 X(1.0f, 0.0f, 0.0f);
static const vmath::vec3 Y(0.0f, 1.0f, 0.0f);
static const vmath::vec3 Z(0.0f, 0.0f, 1.0f);
glDisable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
glClearDepth(1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glUseProgram(sort_prog);
vmath::mat4 p(vmath::frustum(-1.0f, 1.0f, aspect, -aspect, 1.0f, 5000.0f));
vmath::mat4 m;
m = vmath::mat4(vmath::translate(0.0f,
0.0f,
100.0f * sinf(6.28318531f * t) - 230.0f) *
vmath::rotate(360.0f * t, X) *
vmath::rotate(360.0f * t * 2.0f, Y) *
vmath::rotate(360.0f * t * 5.0f, Z) *
vmath::translate(0.0f, -80.0f, 0.0f));
glUniformMatrix4fv(model_matrix_pos, 1, GL_FALSE, m[0]);
glUniformMatrix4fv(projection_matrix_pos, 1, GL_FALSE, p);
glEnable(GL_RASTERIZER_DISCARD);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, xfb);
glBeginTransformFeedback(GL_POINTS);
object.Render();
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glDisable(GL_RASTERIZER_DISCARD);
static const vmath::vec4 colors[2] =
{
vmath::vec4(0.8f, 0.8f, 0.9f, 0.5f),
vmath::vec4(0.3f, 1.0f, 0.3f, 0.8f)
};
glUseProgram(render_prog);
glUniform4fv(0, 1, colors[0]);
glBindVertexArray(vao[0]);
glDrawTransformFeedbackStream(GL_TRIANGLES, xfb, 0);
glUniform4fv(0, 1, colors[1]);
glBindVertexArray(vao[1]);
glDrawTransformFeedbackStream(GL_TRIANGLES, xfb, 1);
base::Display();
}
void CubeMapExample::Initialize(const char * title)
{
base::Initialize(title);
skybox_prog = glCreateProgram();
static const char skybox_shader_vs[] =
"#version 330 core\n"
"\n"
"layout (location = 0) in vec3 in_position;\n"
"\n"
"out vec3 tex_coord;\n"
"\n"
"uniform mat4 tc_rotate;\n"
"\n"
"void main(void)\n"
"{\n"
" gl_Position = tc_rotate * vec4(in_position, 1.0);\n"
" tex_coord = in_position;\n"
"}\n"
;
static const char skybox_shader_fs[] =
"#version 330 core\n"
"\n"
"in vec3 tex_coord;\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"uniform samplerCube tex;\n"
"\n"
"void main(void)\n"
"{\n"
" color = texture(tex, tex_coord);\n"
"}\n"
;
vglAttachShaderSource(skybox_prog, GL_VERTEX_SHADER, skybox_shader_vs);
vglAttachShaderSource(skybox_prog, GL_FRAGMENT_SHADER, skybox_shader_fs);
glLinkProgram(skybox_prog);
static const char object_shader_vs[] =
"#version 330 core\n"
"\n"
"layout (location = 0) in vec4 in_position;\n"
"layout (location = 1) in vec3 in_normal;\n"
"\n"
"out vec3 vs_fs_normal;\n"
"out vec3 vs_fs_position;\n"
"\n"
"uniform mat4 mat_mvp;\n"
"uniform mat4 mat_mv;\n"
"\n"
"void main(void)\n"
"{\n"
" gl_Position = mat_mvp * in_position;\n"
" vs_fs_normal = mat3(mat_mv) * in_normal;\n"
" vs_fs_position = (mat_mv * in_position).xyz;\n"
"}\n"
;
static const char object_shader_fs[] =
"#version 330 core\n"
"\n"
"in vec3 vs_fs_normal;\n"
"in vec3 vs_fs_position;\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"uniform samplerCube tex;\n"
"\n"
"void main(void)\n"
"{\n"
" vec3 tc = reflect(vs_fs_position, normalize(vs_fs_normal));\n"
" color = vec4(0.3, 0.2, 0.1, 1.0) + vec4(0.97, 0.83, 0.79, 0.0) * texture(tex, tc);\n"
"}\n"
;
object_prog = glCreateProgram();
vglAttachShaderSource(object_prog, GL_VERTEX_SHADER, object_shader_vs);
vglAttachShaderSource(object_prog, GL_FRAGMENT_SHADER, object_shader_fs);
glLinkProgram(object_prog);
glGenBuffers(1, &cube_vbo);
glBindBuffer(GL_ARRAY_BUFFER, cube_vbo);
static const GLfloat cube_vertices[] =
{
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f
};
static const GLushort cube_indices[] =
{
0, 1, 2, 3, 6, 7, 4, 5, // First strip
2, 6, 0, 4, 1, 5, 3, 7 // Second strip
};
glBufferData(GL_ARRAY_BUFFER, sizeof(cube_vertices), cube_vertices, GL_STATIC_DRAW);
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));
glEnableVertexAttribArray(0);
glGenBuffers(1, &cube_element_buffer);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, cube_element_buffer);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(cube_indices), cube_indices, GL_STATIC_DRAW);
skybox_rotate_loc = glGetUniformLocation(skybox_prog, "tc_rotate");
object_mat_mvp_loc = glGetUniformLocation(object_prog, "mat_mvp");
object_mat_mv_loc = glGetUniformLocation(object_prog, "mat_mv");
vglImageData image;
tex = vglLoadTexture("../../media/TantolundenCube.dds", 0, &image);
GLenum e;
e = glGetError();
vglUnloadImage(&image);
object.LoadFromVBM("../../media/unit_torus.vbm", 0, 1, 2);
}
void InstanceIDExample::Initialize(const char * title)
{
int n;
base::Initialize(title);
// Create the program for rendering the model
render_prog = glCreateProgram();
// This is the rendering vertex shader
static const char render_vs[] =
"#version 410\n"
"\n"
"// 'position' and 'normal' are regular vertex attributes\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"// Color is a per-instance attribute\n"
"layout (location = 2) in vec4 color;\n"
"\n"
"// The view matrix and the projection matrix are constant across a draw\n"
"uniform mat4 view_matrix;\n"
"uniform mat4 projection_matrix;\n"
"\n"
"// These are the TBOs that hold per-instance colors and per-instance\n"
"// model matrices\n"
"uniform samplerBuffer color_tbo;\n"
"uniform samplerBuffer model_matrix_tbo;\n"
"\n"
"// The output of the vertex shader (matched to the fragment shader)\n"
"out VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec4 color;\n"
"} vertex;\n"
"\n"
"// Ok, go!\n"
"void main(void)\n"
"{\n"
" // Use gl_InstanceID to obtain the instance color from the color TBO\n"
" vec4 color = texelFetch(color_tbo, gl_InstanceID);\n"
"\n"
" // Generating the model matrix is more complex because you can't\n"
" // store mat4 data in a TBO. Instead, we need to store each matrix\n"
" // as four vec4 variables and assemble the matrix in the shader.\n"
" // First, fetch the four columns of the matrix (remember, matrices are\n"
" // stored in memory in column-primary order).\n"
" vec4 col1 = texelFetch(model_matrix_tbo, gl_InstanceID * 4);\n"
" vec4 col2 = texelFetch(model_matrix_tbo, gl_InstanceID * 4 + 1);\n"
" vec4 col3 = texelFetch(model_matrix_tbo, gl_InstanceID * 4 + 2);\n"
" vec4 col4 = texelFetch(model_matrix_tbo, gl_InstanceID * 4 + 3);\n"
"\n"
" // Now assemble the four columns into a matrix.\n"
" mat4 model_matrix = mat4(col1, col2, col3, col4);\n"
"\n"
" // Construct a model-view matrix from the uniform view matrix\n"
" // and the per-instance model matrix.\n"
" mat4 model_view_matrix = view_matrix * model_matrix;\n"
"\n"
" // Transform position by the model-view matrix, then by the\n"
" // projection matrix.\n"
" gl_Position = projection_matrix * (model_view_matrix * position);\n"
" // Transform the normal by the upper-left-3x3-submatrix of the\n"
" // model-view matrix\n"
" vertex.normal = mat3(model_view_matrix) * normal;\n"
" // Pass the per-instance color through to the fragment shader.\n"
" vertex.color = color;\n"
"}\n";
// Simple fragment shader
static const char render_fs[] =
"#version 410\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"in VERTEX\n"
"{\n"
" vec3 normal;\n"
" vec4 color;\n"
"} vertex;\n"
"\n"
"void main(void)\n"
"{\n"
" color = vertex.color * (0.1 + abs(vertex.normal.z)) + vec4(0.8, 0.9, 0.7, 1.0) * pow(abs(vertex.normal.z), 40.0);\n"
"}\n";
// Compile and link like normal
vglAttachShaderSource(render_prog, GL_VERTEX_SHADER, render_vs);
vglAttachShaderSource(render_prog, GL_FRAGMENT_SHADER, render_fs);
glLinkProgram(render_prog);
glUseProgram(render_prog);
// Get the location of the projetion_matrix uniform
view_matrix_loc = glGetUniformLocation(render_prog, "view_matrix");
projection_matrix_loc = glGetUniformLocation(render_prog, "projection_matrix");
// Set up the TBO samplers
GLuint color_tbo_loc = glGetUniformLocation(render_prog, "color_tbo");
GLuint model_matrix_tbo_loc = glGetUniformLocation(render_prog, "model_matrix_tbo");
// Set them to the right texture unit indices
glUniform1i(color_tbo_loc, 0);
glUniform1i(model_matrix_tbo_loc, 1);
// Load the object
object.LoadFromVBM("../../media/armadillo_low.vbm", 0, 1, 2);
/*
THIS IS COMMENTED OUT HERE BECAUSE THE VBM OBJECT TAKES
CARE OF IT FOR US
// Get the locations of the vertex attributes in 'prog', which is the
// (linked) program object that we're going to be rendering with. Note
// that this isn't really necessary because we specified locations for
// all the attributes in our vertex shader. This code could be made
// more concise by assuming the vertex attributes are where we asked
// the compiler to put them.
int position_loc = glGetAttribLocation(prog, "position");
int normal_loc = glGetAttribLocation(prog, "normal");
// Configure the regular vertex attribute arrays - position and normal.
glBindBuffer(GL_ARRAY_BUFFER, position_buffer);
glVertexAttribPointer(position_loc, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(position_loc);
glBindBuffer(GL_ARRAY_BUFFER, normal_buffer);
glVertexAttribPointer(normal_loc, 3, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(normal_loc);
*/
// Now we set up the TBOs for the instance colors and the model matrices...
// First, create the TBO to store colors, bind a buffer to it and initialize
// its format. The buffer has previously been created and sized to store one
// vec4 per-instance.
glGenTextures(1, &color_tbo);
glBindTexture(GL_TEXTURE_BUFFER, color_tbo);
// Generate the colors of the objects
vec4 colors[INSTANCE_COUNT];
for (n = 0; n < INSTANCE_COUNT; n++)
{
float a = float(n) / 4.0f;
float b = float(n) / 5.0f;
float c = float(n) / 6.0f;
colors[n][0] = 0.5f + 0.25f * (sinf(a + 1.0f) + 1.0f);
colors[n][1] = 0.5f + 0.25f * (sinf(b + 2.0f) + 1.0f);
colors[n][2] = 0.5f + 0.25f * (sinf(c + 3.0f) + 1.0f);
colors[n][3] = 1.0f;
}
// Create the buffer, initialize it and attach it to the buffer texture
glGenBuffers(1, &color_buffer);
glBindBuffer(GL_TEXTURE_BUFFER, color_buffer);
glBufferData(GL_TEXTURE_BUFFER, sizeof(colors), colors, GL_STATIC_DRAW);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, color_buffer);
// Now do the same thing with a TBO for the model matrices. The buffer object
// (model_matrix_buffer) has been created and sized to store one mat4 per-
// instance.
glGenTextures(1, &model_matrix_tbo);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_BUFFER, model_matrix_tbo);
glGenBuffers(1, &model_matrix_buffer);
glBindBuffer(GL_TEXTURE_BUFFER, model_matrix_buffer);
glBufferData(GL_TEXTURE_BUFFER, INSTANCE_COUNT * sizeof(mat4), NULL, GL_DYNAMIC_DRAW);
glTexBuffer(GL_TEXTURE_BUFFER, GL_RGBA32F, model_matrix_buffer);
glActiveTexture(GL_TEXTURE0);
}
void LightingExample::Initialize(const char * title)
{
base::Initialize(title);
// Now create a simple program to visualize the result
render_prog = glCreateProgram();
static const char render_vs[] =
"#version 430 core\n"
"\n"
"uniform mat4 model_matrix;\n"
"uniform mat4 proj_matrix;\n"
"\n"
"layout (location = 0) in vec4 position;\n"
"layout (location = 1) in vec3 normal;\n"
"\n"
"out vec3 vs_worldpos;\n"
"out vec3 vs_normal;\n"
"\n"
"void main(void)\n"
"{\n"
" vec4 position = proj_matrix * model_matrix * position;\n"
" gl_Position = position;\n"
" vs_worldpos = position.xyz;\n"
" vs_normal = mat3(model_matrix) * normal;\n"
"}\n"
;
static const char render_fs[] =
"#version 430 core\n"
"\n"
"layout (location = 0) out vec4 color;\n"
"\n"
"in vec3 vs_worldpos;\n"
"in vec3 vs_normal;\n"
"\n"
"uniform vec4 color_ambient = vec4(0.1, 0.2, 0.5, 1.0);\n"
"uniform vec4 color_diffuse = vec4(0.2, 0.3, 0.6, 1.0);\n"
"uniform vec4 color_specular = vec4(0.0); // vec4(1.0, 1.0, 1.0, 1.0);\n"
"uniform float shininess = 77.0f;\n"
"\n"
"uniform vec3 light_position = vec3(12.0f, 32.0f, 560.0f);\n"
"\n"
"void main(void)\n"
"{\n"
" vec3 light_direction = normalize(light_position - vs_worldpos);\n"
" vec3 normal = normalize(vs_normal);\n"
" vec3 half_vector = normalize(light_direction + normalize(vs_worldpos));\n"
" float diffuse = max(0.0, dot(normal, light_direction));\n"
" float specular = pow(max(0.0, dot(vs_normal, half_vector)), shininess);\n"
" color = color_ambient + diffuse * color_diffuse + specular * color_specular;\n"
"}\n";
vglAttachShaderSource(render_prog, GL_VERTEX_SHADER, render_vs);
vglAttachShaderSource(render_prog, GL_FRAGMENT_SHADER, render_fs);
glLinkProgram(render_prog);
mv_mat_loc = glGetUniformLocation(render_prog, "model_matrix");
prj_mat_loc = glGetUniformLocation(render_prog, "proj_matrix");
col_amb_loc = glGetUniformLocation(render_prog, "color_ambient");
col_diff_loc = glGetUniformLocation(render_prog, "color_diffuse");
col_spec_loc = glGetUniformLocation(render_prog, "color_specular");
object.LoadFromVBM("D:\\svn\\Vermilion-Book2\\trunk\\Code\\media\\unit_torus.vbm", 0, 1, 2);
}
void ShadowMapExample::Initialize(const char * title)
{
base::Initialize(title);
// Create the program for rendering the scene from the light's POV.
glCreateProgram();
//光照着色器用于生成阴影
ShaderInfo light_shaders[] =
{
{ GL_VERTEX_SHADER, "shadowmap_shadow.vs.glsl" },
{ GL_FRAGMENT_SHADER, "shadowmap_shadow.fs.glsl" },
{ GL_NONE }
};
render_light_prog = LoadShaders(light_shaders);
// Get the location of the projetion_matrix uniform
render_light_uniforms.model_view_projection_matrix = glGetUniformLocation(render_light_prog, "model_view_projection_matrix");
// Create the program for rendering the scene from the viewer's position
//场景着色器用于渲染场景最终显示
ShaderInfo scene_shaders[] =
{
{ GL_VERTEX_SHADER, "shadowmap_scene.vs.glsl" },
{ GL_FRAGMENT_SHADER, "shadowmap_scene.fs.glsl" },
{ GL_NONE }
};
render_scene_prog = LoadShaders(scene_shaders);
// Get the locations of all the uniforms in the program
render_scene_uniforms.model_matrix = glGetUniformLocation(render_scene_prog, "model_matrix");
render_scene_uniforms.view_matrix = glGetUniformLocation(render_scene_prog, "view_matrix");
render_scene_uniforms.projection_matrix = glGetUniformLocation(render_scene_prog, "projection_matrix");
render_scene_uniforms.shadow_matrix = glGetUniformLocation(render_scene_prog, "shadow_matrix");
render_scene_uniforms.light_position = glGetUniformLocation(render_scene_prog, "light_position");
render_scene_uniforms.material_ambient = glGetUniformLocation(render_scene_prog, "material_ambient");
render_scene_uniforms.material_diffuse = glGetUniformLocation(render_scene_prog, "material_diffuse");
render_scene_uniforms.material_specular = glGetUniformLocation(render_scene_prog, "material_specular");
render_scene_uniforms.material_specular_power = glGetUniformLocation(render_scene_prog, "material_specular_power");
// Set the depth texture uniform to unit 0
//注意uniform变量的赋值时必须设置的是当前绑定的着色器程序
glUseProgram(render_scene_prog);
GLint render_sence_uniforms_texture = glGetUniformLocation(render_scene_prog, "depth_texture");
glUniform1i(render_sence_uniforms_texture, 0);
// Create a depth texture
//创建深度纹理并绑定
glGenTextures(1, &depth_texture);
glBindTexture(GL_TEXTURE_2D, depth_texture);
//为深度纹理分配数据空间，注意纹理内部格式为GL_DEPTH_COMPONENT32，纹理大小设置为与帧缓存大小相同
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT32, DEPTH_TEXTURE_SIZE, DEPTH_TEXTURE_SIZE, 0, GL_DEPTH_COMPONENT, GL_FLOAT, NULL);
//设置纹理滤波模式为线性滤波
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//设置纹理比较模式
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_REF_TO_TEXTURE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
//设置边界截取模式
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_2D, 0);
// Create FBO to render depth into
//创建帧缓存对象用于阴影生成
glGenFramebuffers(1, &depth_fbo);
glBindFramebuffer(GL_FRAMEBUFFER, depth_fbo);
//将纹理图的0级别关联作为帧缓存附件到FBO
//注意当纹理内部格式如上为GL_DEPTH_COMPONENT32时，attachment参数需设置为GL_DEPTH_ATTACHMENT
glFramebufferTexture(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_texture, 0);
//禁止渲染颜色，因为没有设置颜色附件点
glDrawBuffer(GL_NONE);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
// Upload geometry for the ground plane
static const float ground_vertices[] =
{
-500.0f, -50.0f, -500.0f, 1.0f,
-500.0f, -50.0f, 500.0f, 1.0f,
500.0f, -50.0f, 500.0f, 1.0f,
500.0f, -50.0f, -500.0f, 1.0f,
};
static const float ground_normals[] =
{
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 1.0f, 0.0f
};
//地平面数据设置
glGenVertexArrays(1, &ground_vao);
glGenBuffers(1, &ground_vbo);
glBindVertexArray(ground_vao);
glBindBuffer(GL_ARRAY_BUFFER, ground_vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(ground_vertices) + sizeof(ground_normals), NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(ground_vertices), ground_vertices);
glBufferSubData(GL_ARRAY_BUFFER, sizeof(ground_vertices), sizeof(ground_normals), ground_normals);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, NULL);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (const GLvoid *)sizeof(ground_vertices));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
// Load the object
object.LoadFromVBM("armadillo_low.vbm", 0, 1, 2);
}
