bool render() { // Render meshes for (auto &e : meshes) { auto m = e.second; // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), // Location of uniform 1, // Number of values - 1 mat4 GL_FALSE, // Transpose the matrix? value_ptr(MVP)); // Pointer to matrix data // ********************************* // Set N matrix uniform - remember - 3x3 matrix glUniformMatrix3fv(eff.get_uniform_location("N"), 1, GL_FALSE, value_ptr(m.get_transform().get_transform_matrix())); // Set material colour - all objects red glUniform4fv(eff.get_uniform_location("material_colour"), 1, value_ptr(vec4(1.0f, 0.0f, 0.0f, 1.0f))); // Set light colour- (1.0, 1.0, 1.0, 1.0) glUniform4fv(eff.get_uniform_location("light_colour"), 1, value_ptr(vec4(1.0f, 1.0f, 1.0f, 1.0f))); // Set light direction - (1.0, 1.0, -1.0) glUniform3fv(eff.get_uniform_location("light_dir"), 1, value_ptr(vec3(1.0f, 1.0f, -1.0f))); // ********************************* // Render mesh renderer::render(m); } return true; }
bool load_content() { geom.set_type(GL_TRIANGLE_STRIP); // Create quad data // Positions vector<vec3> positions{vec3(-1.0f, -1.0f, 0.0f), vec3(1.0f, -1.0f, 0.0f), vec3(-1.0f, 1.0f, 0.0f), vec3(1.0f, 1.0f, 0.0f)}; // Colours vector<vec4> colours{vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f)}; // Add to the geometry geom.add_buffer(positions, BUFFER_INDEXES::POSITION_BUFFER); geom.add_buffer(colours, BUFFER_INDEXES::COLOUR_BUFFER); // Load in shaders eff.add_shader("shaders/basic.vert", GL_VERTEX_SHADER); eff.add_shader("shaders/basic.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Set camera properties cam.set_position(vec3(10.0f, 10.0f, 10.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool load_content() { // ********************************* // Create a sphere // Create box geometry for skybox // Scale box by 100 - allows a distance // Load the cubemap - create array of six filenames +x, -x, +y, -y, +z, -z // Create cube_map // Load in tarnish texture // Load in environment map shader // Build effect // Load in skybox effect // Build effect // ********************************* // Set camera properties cam.set_position(vec3(0.0f, 0.0f, 10.0f)); cam.set_projection(quarter_pi<float>(), renderer::get_screen_aspect(), 0.1f, 1000.0f); return true; }
bool render() { // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), // Location of uniform 1, // Number of values - 1 mat4 GL_FALSE, // Transpose the matrix? value_ptr(MVP)); // Pointer to matrix data // ********************************* // Bind texture to renderer renderer::bind(tex, 1); // Set the texture value for the shader here glUniform1i(eff.get_uniform_location(" tex"), 0); // ********************************* // Render the mesh renderer::render(m); return true; }
bool render() { // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv( eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // Bind and set texture renderer::bind(tex, 0); glUniform1i(eff.get_uniform_location("tex"), 0); // Render mesh renderer::render(m); return true; }
bool load_content() { // Create mesh object, cheating and using the mesh builder for now m = mesh(geometry_builder::create_box()); // Scale geometry m.get_transform().scale = vec3(10.0f); // Load in dissolve shader eff.add_shader("33_Dissolve/dissolve.vert", GL_VERTEX_SHADER); eff.add_shader("33_Dissolve/dissolve.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Load in textures tex = texture("textures/checker.png"); dissolve = texture("textures/blend_map2.jpg"); // Set camera properties cam.set_position(vec3(30.0f, 30.0f, 30.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool render() { // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), // Location of uniform 1, // Number of values - 1 mat4 GL_FALSE, // Transpose the matrix? value_ptr(MVP)); // Pointer to matrix data // ********************************* // Set the dissolve_factor uniform value // Bind the two textures - use different index for each // Set the uniform values for textures - use correct index // ********************************* // Set UV_scroll uniform, adds cool movent (Protip: This is a super easy way to do fire effects;)) glUniform2fv(eff.get_uniform_location("UV_SCROLL"), 1, value_ptr(uv_scroll)); // Render the mesh renderer::render(m); return true; }
bool load_content() { // ************* // Load in model // ************* m = mesh(geometry("..\\resources\\models\\teapot.obj")); // *************** // Load in texture // *************** tex = texture("..\\resources\\textures\\checked.gif", false, false); // Load in shaders eff.add_shader("..\\resources\\shaders\\simple_texture.vert", GL_VERTEX_SHADER); eff.add_shader("..\\resources\\shaders\\simple_texture.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Set camera properties cam.set_position(vec3(200.0f, 200.0f, 200.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool render() { // Render meshes for (auto &e : meshes) { auto m = e.second; // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // ********************************* // Set material colour - all objects red glUniform4fv(eff.get_uniform_location("material_colour"), 1, value_ptr(vec4(1.0f, 0.0f, 0.0f, 1.0f))); // Set ambient intensity - (0.3, 0.3, 0.3, 1.0) glUniform4fv(eff.get_uniform_location("ambient_intensity"), 1, value_ptr(vec4(0.3f, 0.3f, 0.3f, 1.0))); // ********************************* // Render mesh renderer::render(m); } return true; }
bool render() { // ********************************* // Set render target to frame buffer renderer::set_render_target(frame); // Clear frame renderer::clear(); // ********************************* // Render meshes for (auto &e : meshes) { auto m = e.second; // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // Create MV matrix auto MV = V * M; // Set MV matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MV"), 1, GL_FALSE, value_ptr(MV)); // Set M matrix uniform glUniformMatrix4fv(eff.get_uniform_location("M"), 1, GL_FALSE, value_ptr(M)); // Set N matrix uniform glUniformMatrix3fv(eff.get_uniform_location("N"), 1, GL_FALSE, value_ptr(m.get_transform().get_normal_matrix())); // Bind material renderer::bind(m.get_material(), "mat"); // Bind light renderer::bind(light, "light"); // Bind texture renderer::bind(tex, 0); // Set tex uniform glUniform1i(eff.get_uniform_location("tex"), 0); // Set eye position glUniform3fv(eff.get_uniform_location("eye_pos"), 1, value_ptr(cam.get_position())); // Render mesh renderer::render(m); } // ********************************* // Set render target back to the screen renderer::set_render_target(); // Bind Tex effect renderer::bind(tex_eff); // MVP is now the identity matrix auto MVP = glm::mat4(); // Set MVP matrix uniform glUniformMatrix4fv(tex_eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // Bind texture from frame buffer renderer::bind(frame.get_frame(), 0); // Set the tex uniform glUniform1i(tex_eff.get_uniform_location("tex"), 0); // Render the screen quad renderer::render(screen_quad); // ********************************* return true; }
bool render() { // Render meshes for (auto &e : meshes) { auto m = e.second; // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // ********************************* // Set M matrix uniform glUniformMatrix4fv(eff.get_uniform_location("M"), 1, GL_FALSE, value_ptr(m.get_transform().get_transform_matrix())); // Set N matrix uniform - remember - 3x3 matrix glUniformMatrix3fv(eff.get_uniform_location("N"), 1, GL_FALSE, value_ptr(m.get_transform().get_normal_matrix())); // Set material colour - specular material is white glUniform4fv(eff.get_uniform_location("material_colour"), 1, value_ptr(vec4(1.0f, 1.0f, 1.0f, 1.0f))); // Set shininess - Use 50.0f glUniform1f(eff.get_uniform_location("shininess"), 50.0f); // Set light colour - (1.0, 1.0, 1.0, 1.0) glUniform4fv(eff.get_uniform_location("light_colour"), 1, value_ptr(vec4(1.0f, 1.0f, 1.0f, 1.0f))); // Set light direction- (1.0, 1.0, -1.0) glUniform3fv(eff.get_uniform_location("light_dir"), 1, value_ptr(vec3(1.0f, 1.0f, -1.0f))); // Set eye position - Get this from active camera glUniform3fv(eff.get_uniform_location("eye_pos"), 1, value_ptr(vec3(cam.get_position()))); // ********************************* // Render mesh renderer::render(m); } return true; }
bool update(float delta_time) { // Update camera static float x = 0.0f; x += delta_time; cam.set_position(vec3(10.0f * sinf(x), 10.0f, 10.0f * cosf(x))); cam.update(delta_time); return true; }
bool load_content() { // ********************************* // Create shadow map- use screen size shadow = shadow_map(renderer::get_screen_width(), renderer::get_screen_height()); // Create plane mesh meshes["plane"] = mesh(geometry_builder::create_plane()); // Create "teapot" mesh by loading in models/teapot.obj meshes["teapot"] = mesh(geometry("models/teapot.obj")); // Need to rotate the teapot on x by negative pi/2 meshes["teapot"].get_transform().rotate(vec3(-90.0, 0.0, 0.0)); // Scale the teapot - (0.1, 0.1, 0.1) meshes["teapot"].get_transform().scale = vec3(0.1,0.1,0.1); // *********************** // Set materials // - all emissive is black // - all specular is white // - all shininess is 25 // *********************** // White plane meshes["plane"].get_material().set_emissive(vec4(0.0f, 0.0f, 0.0f, 1.0f)); meshes["plane"].get_material().set_diffuse(vec4(1.0f, 1.0f, 1.0f, 1.0f)); meshes["plane"].get_material().set_specular(vec4(1.0f, 1.0f, 1.0f, 1.0f)); meshes["plane"].get_material().set_shininess(25.0f); // Red teapot meshes["teapot"].get_material().set_emissive(vec4(0.0f, 0.0f, 0.0f, 1.0f)); meshes["teapot"].get_material().set_diffuse(vec4(1.0f, 0.0f, 0.0f, 1.0f)); meshes["teapot"].get_material().set_specular(vec4(1.0f, 1.0f, 1.0f, 1.0f)); meshes["teapot"].get_material().set_shininess(25.0f); // ********************************* // Set spot properties // Pos (20, 30, 0), White // Direction (-1, -1, 0) normalized // 50 range, 10 power spot.set_position(vec3(20.0f, 30.0f, 0.0f)); spot.set_light_colour(vec4(1.0f, 1.0f, 1.0f, 1.0f)); spot.set_direction(normalize(vec3(-1.0f, -1.0f, 0.0f))); spot.set_range(50.0f); spot.set_power(10.0f); // Load in shaders shadow_eff.add_shader("50_Spot_Light/spot.vert", GL_VERTEX_SHADER); shadow_eff.add_shader("50_Spot_Light/spot.frag", GL_FRAGMENT_SHADER); // Build effect shadow_eff.build(); // Set camera properties cam.set_position(vec3(0.0f, 20.0f, -30.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); cam.set_projection(quarter_pi<float>(), renderer::get_screen_aspect(), 0.1f, 1000.0f); return true; }
bool load_content() { // Create cube data - eight corners // Positions vector<vec3> positions{ // ********************************* // Add the position data for cube corners here (8 total) // ********************************* }; // Colours vector<vec4> colours; for (auto i = 0; i < positions.size(); ++i) { colours.push_back(vec4((i + 1) % 2, 0.0f, i % 2, 1.0f)); } // Create the index buffer vector<GLuint> indices{ // ********************************* // Add index information here - 3 per triangle, 6 per face, 12 triangles // Front // Back // Right // Left // Top // Bottom // ********************************* }; // Add to the geometry geom.add_buffer(positions, BUFFER_INDEXES::POSITION_BUFFER); geom.add_buffer(colours, BUFFER_INDEXES::COLOUR_BUFFER); // **************************** // Add index buffer to geometry // **************************** geom.add_index_buffer(indices); // Load in shaders eff.add_shader("shaders/basic.vert", GL_VERTEX_SHADER); eff.add_shader("shaders/basic.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Set camera properties cam.set_position(vec3(10.0f, 10.0f, 10.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool render() { // Bind effect renderer::bind(eff); // Create MVP matrix mat4 M = eulerAngleXZ(theta, rho); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // Render geometry renderer::render(geom); return true; }
bool load_content() { // ************************** // Set geometry type to quads // ************************** geom.set_type(GL_QUADS); // Create quad data // Positions vector<vec3> positions { // *********************************************** // Add the four positions of the quad corners here // *********************************************** vec3(-1.0f, 1.0f, 0.0f), vec3(-1.0f, -1.0f, 0.0f), vec3(1.0f, -1.0f, 0.0f), vec3(1.0f, 1.0f, 0.0f) }; // Colours vector<vec4> colours { vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f) }; // Add to the geometry geom.add_buffer(positions, BUFFER_INDEXES::POSITION_BUFFER); geom.add_buffer(colours, BUFFER_INDEXES::COLOUR_BUFFER); // Load in shaders eff.add_shader( "..\\resources\\shaders\\basic.vert", // filename GL_VERTEX_SHADER); // type eff.add_shader( "..\\resources\\shaders\\basic.frag", // filename GL_FRAGMENT_SHADER); // type // Build effect eff.build(); // Set camera properties cam.set_position(vec3(10.0f, 10.0f, 10.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool update(float delta_time) { // ********************************* // Use keyboard to change camera location // 1 - (50, 10, 50) if (glfwGetKey(renderer::get_window(), GLFW_KEY_UP)) { cam.set_position(vec3(50.0f, 10.0f, 50.0f)); } // 2 - (-50, 10, 50) // 3 - (-50, 10, -50) // 4 - (50, 10, -50) // Update the camera // ********************************* return true; }
bool render() { // Bind effect renderer::bind(eff); // Create MVP matrix mat4 M(1.0f); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), 1, GL_FALSE, value_ptr(MVP)); // ********************************* // Render the mesh here renderer::render(m); // ********************************* return true; }
bool update(float delta_time) { // Accumulate time total_time += delta_time; // Update the scale - base on sin wave s = 1.0f + sinf(total_time); // Multiply by 5 s *= 5.0f; // Increment theta - half a rotation per second theta += pi<float>() * delta_time; // Check if key is pressed if (glfwGetKey(renderer::get_window(), GLFW_KEY_UP)) { pos += vec3(0.0f, 0.0f, -5.0f) * delta_time; } if (glfwGetKey(renderer::get_window(), GLFW_KEY_DOWN)) { pos += vec3(0.0f, 0.0f, 5.0f) * delta_time; } if (glfwGetKey(renderer::get_window(), GLFW_KEY_LEFT)) { pos += vec3(-5.0f, 0.0f, 0.0f) * delta_time; } if (glfwGetKey(renderer::get_window(), GLFW_KEY_RIGHT)) { pos += vec3(5.0f, 0.0f, 0.0f) * delta_time; } // Update the camera cam.update(delta_time); return true; }
bool render() { // Bind effect renderer::bind(eff); // Create MVP matrix mat4 M(1.0f); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), // Location of uniform 1, // Number of values - 1 mat4 GL_FALSE, // Transpose the matrix? value_ptr(MVP)); // Pointer to matrix data // Render geometry renderer::render(geom); return true; }
bool load_content() { // Create plane mesh meshes["plane"] = mesh(geometry_builder::create_plane()); // Create scene meshes["box"] = mesh(geometry_builder::create_box()); meshes["tetra"] = mesh(geometry_builder::create_tetrahedron()); meshes["pyramid"] = mesh(geometry_builder::create_pyramid()); meshes["disk"] = mesh(geometry_builder::create_disk(20)); meshes["cylinder"] = mesh(geometry_builder::create_cylinder(20, 20)); meshes["sphere"] = mesh(geometry_builder::create_sphere(20, 20)); meshes["torus"] = mesh(geometry_builder::create_torus(20, 20, 1.0f, 5.0f)); // Transform objects meshes["box"].get_transform().scale = vec3(5.0f, 5.0f, 5.0f); meshes["box"].get_transform().translate(vec3(-10.0f, 2.5f, -30.0f)); meshes["tetra"].get_transform().scale = vec3(4.0f, 4.0f, 4.0f); meshes["tetra"].get_transform().translate(vec3(-30.0f, 10.0f, -10.0f)); meshes["pyramid"].get_transform().scale = vec3(5.0f, 5.0f, 5.0f); meshes["pyramid"].get_transform().translate(vec3(-10.0f, 7.5f, -30.0f)); meshes["disk"].get_transform().scale = vec3(3.0f, 1.0f, 3.0f); meshes["disk"].get_transform().translate(vec3(-10.0f, 11.5f, -30.0f)); meshes["disk"].get_transform().rotate(vec3(half_pi<float>(), 0.0f, 0.0f)); meshes["cylinder"].get_transform().scale = vec3(5.0f, 5.0f, 5.0f); meshes["cylinder"].get_transform().translate(vec3(-25.0f, 2.5f, -25.0f)); meshes["sphere"].get_transform().scale = vec3(2.5f, 2.5f, 2.5f); meshes["sphere"].get_transform().translate(vec3(-25.0f, 10.0f, -25.0f)); meshes["torus"].get_transform().translate(vec3(-25.0f, 10.0f, -25.0f)); meshes["torus"].get_transform().rotate(vec3(half_pi<float>(), 0.0f, 0.0f)); // Load texture tex = texture("textures/checker.png"); // Load in shaders eff.add_shader("27_Texturing_Shader/simple_texture.vert", GL_VERTEX_SHADER); eff.add_shader("27_Texturing_Shader/simple_texture.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Set camera properties cam.set_position(vec3(50.0f, 10.0f, 50.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); cam.set_projection(quarter_pi<float>(), renderer::get_screen_aspect(), 0.1f, 1000.0f); return true; }
bool update(float delta_time) { if (glfwGetKey(renderer::get_window(), '1')) cam.set_position(vec3(50, 10, 50)); if (glfwGetKey(renderer::get_window(), '2')) cam.set_position(vec3(-50, 10, 50)); if (glfwGetKey(renderer::get_window(), '3')) cam.set_position(vec3(-50, 10, -50)); if (glfwGetKey(renderer::get_window(), '4')) cam.set_position(vec3(50, 10, -50)); // Rotate the sphere meshes["sphere"].get_transform().rotate(vec3(0.0f, half_pi<float>(), 0.0f) * delta_time); cam.update(delta_time); return true; }
bool load_content() { // Construct geometry object geometry geom; // Create triangle data // Positions vector<vec3> positions{vec3(0.0f, 1.0f, 0.0f), vec3(-1.0f, -1.0f, 0.0f), vec3(1.0f, -1.0f, 0.0f)}; // ********************************* // Define texture coordinates for triangle vector<vec2> UVs{ vec2(0.0f, 1.0f), vec2(-1.0f, -1.0f), vec2(1.0f, -1.0f) }; // ********************************* // Add to the geometry geom.add_buffer(positions, BUFFER_INDEXES::POSITION_BUFFER); // ********************************* // Add texture coordinate buffer to geometry geom.add_buffer(positions, BUFFER_INDEXES::TEXTURE_COORDS_0); // ********************************* // Create mesh object m = mesh(geom); m2 = mesh(geom); m2.get_transform().translate(vec3(5.0f, 1.0f, 1.0f)); // Load in texture shaders here eff.add_shader("27_Texturing_Shader/simple_texture.vert", GL_VERTEX_SHADER); eff.add_shader("27_Texturing_Shader/simple_texture.frag", GL_FRAGMENT_SHADER); // ********************************* // Build effect eff.build(); // Load texture "textures/sign.jpg" tex = texture("textures/sign.jpg"); tex2 = texture("textures/stonygrass.jpg"); // ********************************* // Set camera properties cam.set_position(vec3(10.0f, 10.0f, 10.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool update(float delta_time) { if (glfwGetKey(renderer::get_window(), '1')) { cam.set_position(vec3(50, 10, 50)); } if (glfwGetKey(renderer::get_window(), '2')) { cam.set_position(vec3(-50, 10, 50)); } if (glfwGetKey(renderer::get_window(), '3')) { cam.set_position(vec3(-50, 10, -50)); } if (glfwGetKey(renderer::get_window(), '4')) { cam.set_position(vec3(50, 10, -50)); } cam.update(delta_time); return true; }
bool load_content() { // Construct geometry object geometry geom; // Required buffers vector<vec3> positions; vector<vec3> normals; // Define the initial tetrahedron - 4 points vector<vec3> v{vec3(0.0f, 0.0f, 1.0f), vec3(0.0f, 0.942809f, -0.333333f), vec3(-0.816497f, -0.471405f, -0.333333f), vec3(0.816497f, -0.471405f, 0.333333f)}; // Divide the triangles divide_triangle({v[0], v[1], v[2]}, subdivisions, positions); divide_triangle({v[3], v[2], v[1]}, subdivisions, positions); divide_triangle({v[0], v[3], v[1]}, subdivisions, positions); divide_triangle({v[0], v[2], v[3]}, subdivisions, positions); // Copy positions (already normalized) into normals buffer normals.insert(normals.end(), positions.begin(), positions.end()); // Add buffers to geometry geom.add_buffer(positions, BUFFER_INDEXES::POSITION_BUFFER); geom.add_buffer(normals, BUFFER_INDEXES::NORMAL_BUFFER); // Create mesh object m = mesh(geom); // Load in simple cell shader eff.add_shader("34_Simple_Cell_Shading/simple_cell.vert", GL_VERTEX_SHADER); eff.add_shader("34_Simple_Cell_Shading/simple_cell.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Colour scale from red to black vector<vec4> colour_data{vec4(0.12f, 0.0f, 0.0f, 1.0f), vec4(0.25f, 0.0f, 0.0f, 1.0f), vec4(0.5f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f)}; // Create 1D 4x1 texture from colour_data tex = texture(colour_data, 4, 1, false, false); // Set camera properties cam.set_position(vec3(10.0f, 10.0f, 10.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool load_content() { // Create quad data - two triangles // Positions geom.set_type(GL_TRIANGLES); // set type only need 4 corners for quad vector<vec3> positions { vec3(1.0, 1.0, 0.0), vec3(0.0, 0.0, -1.0), vec3(2.0, 0, -1.0), }; // Colours vector<vec4> colours { vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f), vec4(1.0f, 0.0f, 0.0f, 1.0f), //vec4(1.0f, 0.0f, 0.0f, 1.0f) //vec4(1.0f, 1.0f, 0.0f, 1.0f), //vec4(1.0f, 1.0f, 0.0f, 1.0f) }; // Add to the geometry geom.add_buffer(positions, BUFFER_INDEXES::POSITION_BUFFER); geom.add_buffer(colours, BUFFER_INDEXES::COLOUR_BUFFER); // Load in shaders eff.add_shader( "..\\resources\\shaders\\basic.vert", // filename GL_VERTEX_SHADER); // type eff.add_shader( "..\\resources\\shaders\\basic.frag", // filename GL_FRAGMENT_SHADER); // type // Build effect eff.build(); // Set camera properties cam.set_position(vec3(10.0f, 10.0f, 10.0f)); cam.set_target(vec3(0.0f, 0.0f, 1.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool load_content() { // Set to points type geom.set_type(GL_POINTS); // Create sierpinski gasket create_sierpinski(geom); // Load in shaders eff.add_shader("shaders/basic.vert", GL_VERTEX_SHADER); eff.add_shader("shaders/basic.frag", GL_FRAGMENT_SHADER); // Build effect eff.build(); // Set camera properties cam.set_position(vec3(2.0f, 2.0f, 2.0f)); cam.set_target(vec3(0.0f, 0.0f, 0.0f)); auto aspect = static_cast<float>(renderer::get_screen_width()) / static_cast<float>(renderer::get_screen_height()); cam.set_projection(quarter_pi<float>(), aspect, 2.414f, 1000.0f); return true; }
bool update(float delta_time) { cam.update(delta_time); // ********************************* // Set skybox position to camera position (camera in centre of skybox) // rotate the sphere // ********************************* return true; }
bool render() { // Render meshes for (auto &e : meshes) { auto m = e.second; // Bind effect renderer::bind(eff); // Create MVP matrix auto M = m.get_transform().get_transform_matrix(); auto V = cam.get_view(); auto P = cam.get_projection(); auto MVP = P * V * M; // Set MVP matrix uniform glUniformMatrix4fv(eff.get_uniform_location("MVP"), // Location of uniform 1, // Number of values - 1 mat4 GL_FALSE, // Transpose the matrix? value_ptr(MVP)); // Pointer to matrix data // ********************************* // Set M matrix uniform glUniformMatrix4fv(eff.get_uniform_location("M"), 1, GL_FALSE, value_ptr(M)); // Set N matrix uniform - remember - 3x3 matrix glUniformMatrix3fv(eff.get_uniform_location("N"), 1, GL_FALSE, value_ptr(m.get_transform().get_normal_matrix())); // Bind material renderer::bind(m.get_material(), "mat"); // Bind light renderer::bind(light, "point"); // Bind texture renderer::bind(tex, 0); // Set tex uniform glUniform1i(eff.get_uniform_location("tex"), 0); // Set eye position- Get this from active camera glUniform3fv(eff.get_uniform_location("eye_pos"), 1, value_ptr(cam.get_position())); // Render mesh renderer::render(m); // ********************************* } return true; }
bool update(float delta_time) { // Use up an down to modify the dissolve factor if (glfwGetKey(renderer::get_window(), GLFW_KEY_UP)) dissolve_factor = clamp(dissolve_factor + 0.1f * delta_time, 0.0f, 1.0f); if (glfwGetKey(renderer::get_window(), GLFW_KEY_DOWN)) dissolve_factor = clamp(dissolve_factor - 0.1f * delta_time, 0.0f, 1.0f); // Update camera cam.update(delta_time); uv_scroll += vec2(0, delta_time * 0.05); return true; }