void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // auto camera = CamMatrixf::Orbiting( Vec3f(), 4.5, Degrees(time * 35), Degrees(SineWave(time / 30.0) * 60) ); auto model = ModelMatrixf::RotationY(FullCircles(time * 0.25)) * ModelMatrixf::RotationX(FullCircles(0.25)); Vec4f lightPos(4.0f, 4.0f, -8.0f, 1.0f); prog.Use(); camera_matrix.Set(camera); model_matrix.Set(model); light_pos_cam.Set(camera * lightPos); front_color.Set(Vec3f(0.3f, 0.2f, 0.0f)); back_color.Set(Vec3f(0.2f, 0.1f, 0.0f)); gl.PolygonMode(PolygonMode::Line); torus_instr.Draw(torus_indices); front_color.Set(Vec3f(0.9f, 0.8f, 0.1f)); back_color.Set(Vec3f(1.0f, 0.9f, 0.8f)); gl.PolygonMode(PolygonMode::Fill); torus_instr.Draw(torus_indices); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // auto lightAzimuth = FullCircles(time * -0.5); light_pos.Set( Vec3f( Cos(lightAzimuth), 1.0f, Sin(lightAzimuth) ) * 2.0f ); // camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 3.0f, Degrees(-45), Degrees(SineWave(time / 30.0) * 70) ) ); // set the model matrix model_matrix.Set( ModelMatrixf::RotationY(FullCircles(time * 0.05)) ); cube.Bind(); gl.CullFace(Face::Back); cube_instr.Draw(cube_indices); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // // set the matrix for camera orbiting the origin camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 4.0 - SineWave(time / 6.0) * 2.0, FullCircles(time * 0.4), Degrees(SineWave(time / 30.0) * 90) ) ); // set the model matrix model_matrix.Set( ModelMatrixf::RotationZ(FullCircles(time * 0.1)) ); cube.Bind(); gl.CullFace(Face::Front); cube_instr.Draw(cube_indices); gl.CullFace(Face::Back); cube_instr.Draw(cube_indices); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // Uniform<Mat4f>(prog, "cameraMatrix").Set( CamMatrixf::Orbiting( Vec3f(), 3.0 + std::sin(time)*1.5, FullCircles(time * 0.5), Degrees(std::sin(time * 0.5) * 70) ) ); Uniform<Mat4f>(prog, "modelMatrix").Set( ModelMatrixf::RotationA( Vec3f(1.0f, 1.0f, 1.0f), FullCircles(time * 0.4) ) ); Uniform<Vec3f>(prog, "lightPos").Set(Vec3f(1.0f, 2.0f, 3.0f*std::sin(time * 2.9))); vao.Bind(); // This is not very effective shape.Instructions().Draw(shape.Indices()); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // auto camera = CamMatrixf::Orbiting( Vec3f(), 4.5, Degrees(time * 35), Degrees(SineWave(time / 30.0) * 60) ); auto model = ModelMatrixf::RotationY(FullCircles(time * 0.25)) * ModelMatrixf::RotationX(FullCircles(time * 0.33)); camera_matrix.Set(camera); model_matrix.Set(model); transf_time.Set(time); face_pp.Bind(); gl.PolygonMode(PolygonMode::Fill); torus_instr.Draw(torus_indices); frame_pp.Bind(); gl.PolygonMode(PolygonMode::Line); torus_instr.Draw(torus_indices); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // // set the matrix for camera orbiting the origin camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 4.5 - SineWave(time / 16.0) * 2.0, FullCircles(time / 12.0), Degrees(SineWave(time / 30.0) * 90) ) ); // set the model matrix model_matrix.Set( ModelMatrixf::RotationA( Vec3f(1.0f, 1.0f, 1.0f), FullCircles(time / 10.0) ) ); shape.Bind(); shape_instr.Draw(shape_indices); }
void Render(double time) { const double day_duration = 67.0; auto sun = Vec3f(0.000, 1.000, 0.000) * 1e10 * SineWave(time / day_duration) + Vec3f(0.000, 0.000, -1.000) * 1e10 * CosineWave(time / day_duration); auto camera = CamMatrixf::Orbiting( Vec3f(), 5.0, FullCircles(-0.10 - time / 27.0), Degrees(-20 - SineWave(time / 17.0) * 30)); auto model = ModelMatrixf::RotationA( Vec3f(1.0, 1.0, 1.0), FullCircles(time / 13.0)); gl.Clear().ColorBuffer().DepthBuffer(); sky_box.Use(); sky_box_prog.Use(); sky_box_camera_matrix.Set(camera); sky_box_sun_position.Set(sun); sky_box.Draw(); shape.Use(); shape_prog.Use(); shape_model_matrix.Set(model); shape_camera_matrix.Set(camera); shape_camera_position.Set(camera.Position()); shape_sun_position.Set(sun); shape.Draw(); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); auto camera = CamMatrixf::Orbiting( Vec3f(), field.Radius()*(1.4 + SineWave(time / 6.0) * 0.2), FullCircles(time * 0.1), Degrees(SineWave(time / 30.0) * 90) ); auto light = CamMatrixf::Orbiting( Vec3f(), field.Radius()*1.6, FullCircles(0.33-time * 0.07), Degrees(SineWave(time / 31.0) * 80) ); prog.camera_matrix.Set(camera); prog.light_position.Set(light.Position()); GLfloat fade_coef = 1.1*(1.0-CosineWave01(time / 90.0)); prog.fade_coef.Set(fade_coef); field.Draw(); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // // set the matrix for camera orbiting the origin camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 3.5, Degrees(time * 35), Degrees(SineWave(time / 20.0) * 60) ) ); // set the model matrix model_matrix.Set( ModelMatrixf::RotationY(FullCircles(time * 0.25)) * ModelMatrixf::RotationX(FullCircles(0.25)) ); gl.PolygonMode(PolygonMode::Line); gl.CullFace(Face::Front); torus_instr.Draw(torus_indices); // gl.PolygonMode(PolygonMode::Fill); gl.CullFace(Face::Back); torus_instr.Draw(torus_indices); }
double Draw(double time) { assert(!shapes.empty()); assert(ishape != shapes.end()); shapes::ShapeWrapper& shape = *ishape; const double interval = 11.0; double segment = time - shape_time; double fade = segment*(interval-segment); fade -= 1.0; if(fade < 0.0) fade = 0.0; fade = std::sqrt(fade/interval); if(fade > 1.0) fade = 1.0; if(segment > interval) { if(++ishape == shapes.end()) { ishape = shapes.begin(); } shape_time = time; } gl.Clear().DepthBuffer(); float dist = (1.0+SineWave(time / 13.0))*2.5; projection_matrix.Set( CamMatrixf::PerspectiveX( Degrees(45), 1.0, 1.0+dist, shape.BoundingSphere().Radius()*2.0+1.0+dist ) ); camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), shape.BoundingSphere().Radius()+1.5+dist, FullCircles(time / 27.0), Degrees(SineWave(time / 23.0) * 89) ) ); model_matrix.Set( ModelMatrixf::RotationA( Vec3f(1,1,1), FullCircles(time /-37.0) ) ); prog.Use(); shape.Use(); shape.Draw(); return fade; }
void Render(double time) { static const ModelMatrixf reflection = ModelMatrixf::Translation(0.0f, -1.0f, 0.0f) * ModelMatrixf::Reflection(false, true, false); auto camera = CamMatrixf::Orbiting( Vec3f(), 4.5, FullCircles(time / 10.0), Degrees(45.0 - SineWave(time / 7.0)*35.0) ); shape_prog.Use(); shape.Bind(); gl.FrontFace(make_shape.FaceWinding()); shape_model_matrix = ModelMatrixf::Translation(0.0f, 1.1f, 0.0f) * ModelMatrixf::RotationX(FullCircles(time / 12.0)); // render into the off-screen framebuffer fbo.Bind(Framebuffer::Target::Draw); gl.Viewport(width/tex_size_div, height/tex_size_div); gl.Clear().ColorBuffer().DepthBuffer(); shape_camera_matrix = camera * reflection; gl.FrontFace(Inverted(make_shape.FaceWinding())); shape_instr.Draw(shape_indices); // render into the on-screen framebuffer dfb.Bind(Framebuffer::Target::Draw); gl.Viewport(width, height); gl.Clear().ColorBuffer().DepthBuffer(); shape_camera_matrix = camera; gl.FrontFace(make_shape.FaceWinding()); shape_instr.Draw(shape_indices); // Render the plane plane_prog.Use(); plane.Bind(); gl.FrontFace(make_plane.FaceWinding()); plane_camera_matrix = camera; plane_model_matrix = ModelMatrixf::Translation(0.0f, -0.5f, 0.0f); plane_instr.Draw(plane_indices); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); CamMatrixf camera = CamMatrixf::Orbiting( Vec3f(), 4.5f + float(SineWave(time / 25.0)), FullCircles(time / 30.0), Degrees(SineWave(time / 19.0) * 20) ); light_prog.camera_matrix.Set(camera); flare_prog.camera_matrix.Set(camera); shape_prog.camera_matrix.Set(camera); shape_prog.camera_position.Set(camera.Position()); shape_prog.model_matrix.Set( ModelMatrixf::RotationX(FullCircles(time / 30.0)) ); shape_prog.Use(); shape.Draw(); NoProgram().Use(); lights.Bind(); light_prog.Use(); for(GLuint l=0; l!=n_flares; ++l) { queries[l].Begin(Query::Target::SamplesPassed); gl.DrawArrays(PrimitiveType::Points, l, 1); queries[l].End(Query::Target::SamplesPassed); } gl.Enable(Capability::Blend); gl.Disable(Capability::DepthTest); flare_prog.Use(); for(GLuint l=0; l!=n_flares; ++l) { GLint samples = 0; queries[l].WaitForResult(samples); if(samples != 0) { flare_prog.samples = samples; gl.DrawArrays(PrimitiveType::Points, l, 1); } } gl.Enable(Capability::DepthTest); gl.Disable(Capability::Blend); }
void Render(double time) { static const Mat4f reflection( Vec4f( 1.0, 0.0, 0.0, 0.0), Vec4f( 0.0,-1.0, 0.0, 0.0), Vec4f( 0.0, 0.0, 1.0, 0.0), Vec4f( 0.0, 0.0, 0.0, 1.0) ); auto camera = CamMatrixf::Orbiting( Vec3f(), GLfloat(7.0 + SineWave(time / 12.0)*2.5), FullCircles(time / 10.0), Degrees(45.0 - SineWave(time / 7.0)*35.0) ); shape_prog.Use(); shape.Bind(); gl.Enable(Capability::CullFace); gl.FrontFace(make_shape.FaceWinding()); // render into the off-screen framebuffer fbo.Bind(Framebuffer::Target::Draw); gl.Viewport( (width - refl_tex_side) / 2, (height - refl_tex_side) / 2, refl_tex_side, refl_tex_side ); gl.Clear().ColorBuffer().DepthBuffer(); shape_camera_matrix.Set( camera * ModelMatrixf::Translation(0.0f, -1.0f, 0.0f) * reflection ); gl.CullFace(Face::Front); shape_instr.Draw(shape_indices); gl.Bind(Framebuffer::Target::Draw, DefaultFramebuffer()); gl.Viewport(width, height); gl.Clear().ColorBuffer().DepthBuffer(); shape_camera_matrix.Set(camera); gl.CullFace(Face::Back); shape_instr.Draw(shape_indices); gl.Disable(Capability::CullFace); // Render the plane plane_prog.Use(); plane.Bind(); plane_camera_matrix.Set(camera); plane_camera_position.Set(camera.Position()); plane_instr.Draw(plane_indices); }
Mat4f ModelMat(double time) { return ModelMatrixf::RotationA( Vec3f(1), FullCircles(time / 13.0) ); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // liquid_prog.time = time; auto camera = CamMatrixf::Orbiting( Vec3f(0, 0, 0), 4.5 - SineWave(time / 14.0), FullCircles(time / 26.0), Degrees(55 + SineWave(time / 14.0) * 30) ); Vec3f camera_position = camera.Position(); liquid_prog.camera_position = camera_position; liquid_prog.camera_matrix = perspective*camera; for(int z=-grid_repeat; z!=grid_repeat; ++z) for(int x=-grid_repeat; x!=grid_repeat; ++x) { liquid_prog.grid_offset.Set(x, -0.5, z); grid.Draw(); } }
void Render(double time) { // update the particle positions, ages and directions GLuint i = 0; float time_diff = (time - prev_time); float age_mult = 0.2f; while(i != positions.size()) { float drag = 0.1f * (time_diff); if((ages[i] += time_diff * age_mult) < 1.0f) { directions[i] *= (1.0f - drag); positions[i] += directions[i]*time_diff; } else { ages[i] = 0.0f; directions[i] = NewDirection(); positions[i] = Vec3f(); } ++i; } // if there are not enough particles yet if(i != particle_count) { float spawn_interval = 1.0f/(age_mult*particle_count); if(prev_spawn + spawn_interval < time) { directions.push_back(NewDirection()); positions.push_back(Vec3f()); ages.push_back(0.0f); prev_spawn = time; } } prev_time = time; assert(positions.size() == directions.size()); assert(positions.size() == ages.size()); // upload the particle positions pos_buf.Bind(Buffer::Target::Array); Buffer::Data(Buffer::Target::Array, positions); // upload the particle ages age_buf.Bind(Buffer::Target::Array); Buffer::Data(Buffer::Target::Array, ages); gl.Clear().ColorBuffer().DepthBuffer(); // // set the matrix for camera orbiting the origin camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 18.0f, FullCircles(time * 0.5), Degrees(45) ) ); gl.DrawArrays(PrimitiveType::Points, 0, positions.size()); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 4.0, Degrees(time * 25), Degrees(SineWave(time / 30.0) * 90) ) ); model_matrix.Set( ModelMatrixf::RotationA( Vec3f(1.0f, 1.0f, 1.0f), FullCircles(time * 0.5) ) ); shape.Draw(); thread_ready.Signal(); parent_ready.Wait(); }
void Render(double time) { const Vec3f light_position(16.0, 10.0, 9.0); const Vec3f torus_center(0.0, 1.5, 0.0); const Mat4f torus_matrix = ModelMatrixf::Translation(torus_center) * ModelMatrixf::RotationZ(FullCircles(time / 16.0)); const Mat4f light_proj_matrix = CamMatrixf::PerspectiveX(Degrees(10), 1.0, 1, 80) * CamMatrixf::LookingAt(light_position, torus_center); transf_prog.light_position.Set(light_position); RenderFrameShadowMap( light_position, torus_matrix, light_proj_matrix ); RenderGlassShadowMap( light_position, torus_center, torus_matrix, light_proj_matrix ); RenderImage( time, torus_center, torus_matrix, light_proj_matrix ); }
void RenderImage(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // Mat4f perspective = CamMatrixf::PerspectiveX(Degrees(48), width, height, 1, 100); auto camera = CamMatrixf::Orbiting( Vec3f(0, 0, 0), GLfloat(4.0 - SineWave(time / 14.0)), FullCircles(time / 26.0), Degrees(45 + SineWave(time / 17.0) * 40)); Vec3f camera_position = camera.Position(); metal_prog.Use(); metal_prog.camera_position.Set(camera_position); metal_prog.camera_matrix.Set(perspective * camera); plane.Use(); plane.Draw(); blob_prog.Use(); blob_prog.camera_position.Set(camera_position); blob_prog.camera_matrix.Set(perspective * camera); grid.Use(); int side = 1; for(int z = -side; z != side; ++z) for(int y = -side; y != side; ++y) for(int x = -side; x != side; ++x) { blob_prog.grid_offset.Set(x, y, z); grid.Draw(); } }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); int period = int(time * 0.125); if(prev_period < period) { if(period % 2) gl.PolygonMode(PolygonMode::Line); else gl.PolygonMode(PolygonMode::Fill); prev_period = period; } auto camera = CamMatrixf::Orbiting( Vec3f(0.0f, 2.0f, 0.0f), 17.0f - CosineWave(time / 31.0f) * 10.0f, FullCircles(time / 43.0f), Degrees(45 - SineWave(time / 29.0f) * 35) ); camera_matrix.Set(camera); camera_position.Set(camera.Position()); anim_time.Set(time); plane_instr.Draw(plane_indices); }
void Render(ExampleClock& clock) { if(long(clock.Now().Seconds()) % 4 == 0) { status += clock.Interval().Seconds(); } else if(status != double(long(status))) { if(status - double(long(status)) < 0.5) status = double(long(status)); else status = 1.0 + double(long(status)); } gl.Clear().ColorBuffer().DepthBuffer(); point_prog.status = GLfloat(0.5 - 0.5 * CosineWave(status * 0.5)); CamMatrixf camera = CamMatrixf::Orbiting( Vec3f(), 5.5f, FullCircles(clock.Now().Seconds() / 19.0), Degrees(45 + SineWave(clock.Now().Seconds() / 15.0) * 40)); point_prog.camera_matrix.Set(camera); point_prog.model_matrix.Set( ModelMatrixf::RotationX(RightAngles(status))); shape.Draw(); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); auto camera = CamMatrixf::Orbiting( Vec3f(), 16.0, FullCircles(time * 0.1), Degrees(SineWave(time / 20.0) * 30) ); // use the picking program pick_prog.Use(); Uniform<Mat4f>(pick_prog, "CameraMatrix").Set(camera); // query the number of values written to the feedabck buffer GLuint picked_count = 0; { Query::Execution<GLuint> query_exec( count_query, Query::Target:: TransformFeedbackPrimitivesWritten, picked_count ); TransformFeedback::Activator xfb_act( TransformFeedbackPrimitiveType::Points ); // draw 36 instances of the cube // the vertex shader will take care of their placement cube_instr.Draw(cube_indices, 36); // xfb_act.Finish(); query_exec.WaitForResult(); } std::map<GLfloat, GLint> picked_objs; { picked_instances.Bind(Buffer::Target::TransformFeedback); BufferTypedMap<DepthAndID> picked_instances_map( Buffer::Target::TransformFeedback, BufferMapAccess::Read ); picked_objs.insert( picked_instances_map.Data(), picked_instances_map.Data()+picked_count ); } draw_prog.Use(); Uniform<GLint> picked(draw_prog, "Picked"); if(picked_objs.empty()) picked = -1; else picked = picked_objs.begin()->second; Uniform<Mat4f>(draw_prog, "CameraMatrix").Set(camera); // draw 36 instances of the cube // the vertex shader will take care of their placement cube_instr.Draw(cube_indices, 36); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); // // set the matrix for camera orbiting the origin camera_matrix.Set( CamMatrixf::Orbiting( Vec3f(), 4.5f, FullCircles(time / 10.0), Degrees(45.0 + SineWave(time / 7.0)*30.0) ) ); model_matrix.Set(ModelMatrixf::RotationX(FullCircles(time / 12.0))); torus_instr.Draw(torus_indices); }
void Render(double time) { auto camera = CamMatrixf::Roll(Degrees(SineWave(time / 11.0)*7+SineWave(time/13.0)*5))* CamMatrixf::Orbiting( Vec3f(), 40.0f, Degrees(SineWave(time / 11.0)*10+CosineWave(time/19.0)*10-90), Degrees(SineWave(time / 17.0)*10+SineWave(time/13.0)*10) ); auto mm_identity = ModelMatrixf(); auto mm_rotation = ModelMatrixf::RotationZ(FullCircles(time / 7.0)); Uniform<Mat4f>* model_matrix = nullptr; GLuint drawing_fan = fan_index; auto drawing_driver = [ &model_matrix, &mm_identity, &mm_rotation, &drawing_fan ](GLuint phase) -> bool { if(phase == drawing_fan) model_matrix->Set(mm_rotation); else model_matrix->Set(mm_identity); return true; }; // render the light mask light_fbo.Bind(Framebuffer::Target::Draw); gl.Clear().ColorBuffer().DepthBuffer(); mask_vao.Bind(); mask_prog.Use(); mask_prog.camera_matrix.Set(camera); model_matrix = &mask_prog.model_matrix; meshes.Draw(drawing_driver); // render the final image DefaultFramebuffer().Bind(Framebuffer::Target::Draw); gl.Clear().ColorBuffer().DepthBuffer(); draw_vao.Bind(); draw_prog.Use(); Vec4f lsp = projection * camera * Vec4f(light_position, 1.0); draw_prog.light_screen_pos = lsp.xyz()/lsp.w(); draw_prog.camera_matrix.Set(camera); model_matrix = &draw_prog.model_matrix; meshes.Draw(drawing_driver); }
Mat4f CameraMat(double time) { return CamMatrixf::Orbiting( Vec3f(0, 0, 0), 5.0 - SineWave(time / 11.0), FullCircles(time / 23.0), Degrees(SineWave(time / 17.0) * 80) ); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); auto camera = CamMatrixf::Orbiting( Vec3f(), 6.0, FullCircles(time / 10.0), Degrees(45.0 + SineWave(time / 7.0)*30.0) ); auto model = ModelMatrixf::RotationX(FullCircles(time / 12.0)); plane_camera_matrix.Set(camera); torus_camera_matrix.Set(camera); torus_model_matrix.Set(model); BSP(camera, 0); }
void Render(ExampleClock& clock) { positions.clear(); ages.clear(); // update the emitters and get the particle data for(auto i=emitters.begin(), e=emitters.end(); i!=e; ++i) { i->Update(clock); i->Upload(positions, ages); } assert(positions.size() == ages.size()); // make a camera matrix auto cameraMatrix = CamMatrixf::Orbiting( Vec3f(), 38.0 - SineWave(clock.Now().Seconds() / 6.0) * 17.0, FullCircles(clock.Now().Seconds() * 0.1), Degrees(SineWave(clock.Now().Seconds() / 20.0) * 60) ); std::vector<float> depths(positions.size()); std::vector<GLuint> indices(positions.size()); // calculate the depths of the particles for(GLuint i=0, n=positions.size(); i!=n; ++i) { depths[i] = (cameraMatrix * Vec4f(positions[i], 1.0)).z(); indices[i] = i; } // sort the indices by the depths std::sort( indices.begin(), indices.end(), [&depths](GLuint i, GLuint j) { return depths[i] < depths[j]; } ); // upload the particle positions pos_buf.Bind(Buffer::Target::Array); Buffer::Data(Buffer::Target::Array, positions, BufferUsage::DynamicDraw); // upload the particle ages age_buf.Bind(Buffer::Target::Array); Buffer::Data(Buffer::Target::Array, ages, BufferUsage::DynamicDraw); gl.Clear().ColorBuffer().DepthBuffer(); camera_matrix.Set(cameraMatrix); // use the indices to draw the particles gl.DrawElements( PrimitiveType::Points, indices.size(), indices.data() ); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); auto camera = CamMatrixf::Orbiting( Vec3f(), 2.9f, FullCircles(time / 17.0), Degrees(45 + SineWave(time / 20.0) * 40)); camera_matrix.Set(camera); camera_position.Set(camera.Position()); auto langle = FullCircles(time / 31.0); light_position.Set( GLfloat(Cos(langle) * 20.0f), GLfloat((1.2 + Sin(langle)) * 15.0f), GLfloat(Sin(langle) * 20.0f)); shape.Draw(); }
void make_shape_2(const Program& prog, int vbo, const GLchar* name) { vbos[vbo].Bind(Buffer::Target::Array); std::vector<GLfloat> data(point_count * 3); auto i = data.begin(), e = data.end(); while(i != e) { auto phi = FullCircles((std::rand() % 1001) * 0.001); auto rho = FullCircles((std::rand() % 1001) * 0.001); *i++ = float(Cos(phi) * (0.5 + 0.5 * (1.0 + Cos(rho)))); *i++ = float(Sin(rho) * 0.5); *i++ = float(Sin(phi) * (0.5 + 0.5 * (1.0 + Cos(rho)))); } Buffer::Data(Buffer::Target::Array, data); VertexArrayAttrib attr(prog, name); attr.Setup<Vec3f>(); attr.Enable(); }
void Render(double time) { gl.Clear().ColorBuffer().DepthBuffer(); auto camera = CamMatrixf::Orbiting( Vec3f(), 8.5, FullCircles(time / 5.0), Degrees(15 + (-SineWave(time/10.0)+1.0)* 0.5 * 75) ); ModelMatrixf model = ModelMatrixf::Translation(0.0f, 2.5f, 0.0) * ModelMatrixf::RotationA( Vec3f(1.0f, 1.0f, 1.0f), FullCircles(time / 7.0) ); plane_prog.Use(); plane_camera_matrix.Set(camera); plane.Bind(); gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4); shape_prog.Use(); shape_camera_matrix.Set(camera); shape_model_matrix.Set(model); shape.Bind(); shape_instr.Draw(shape_indices); halo_prog.Use(); halo_camera_matrix.Set(camera); halo_model_matrix.Set(model); gl.DepthMask(false); gl.Enable(Capability::Blend); shape_instr.Draw(shape_indices); gl.Disable(Capability::Blend); gl.DepthMask(true); }