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); }