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