CubeExample(void)
: gl()
, prog()
, field(
images::FlipImageAxes<GLubyte, 1>(
images::LoadTexture("suzanne_vol"),
0, 2,-1
),
prog
), shadowmaps(
images::LoadTexture("oglcraft_ao"),
prog
)
{
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CCW);
gl.CullFace(Face::Back);
prog.Use();
field.Use();
}
LiquidExample(const ExampleParams& params)
: liquid_prog()
, grid(liquid_prog, params.quality)
, grid_repeat(int(1 + params.quality*2))
{
Texture::Active(1);
{
auto image = images::Squares(512, 512, 0.9f, 8, 8);
auto bound_tex = gl.Bound(Texture::Target::CubeMap, env_map);
for(int i=0; i!=6; ++i)
Texture::ImageCM(i, image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
bound_tex.SwizzleG(TextureSwizzle::Red);
bound_tex.SwizzleB(TextureSwizzle::Red);
}
ProgramUniformSampler(liquid_prog, "EnvMap").Set(1);
const Vec3f light_position(12.0, 1.0, 8.0);
liquid_prog.light_position.Set(light_position);
gl.ClearColor(0.7f, 0.65f, 0.55f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CW);
gl.CullFace(Face::Back);
}
void RenderOffscreen(double time)
{
fbo.Bind();
gl.Clear().ColorBuffer().DepthBuffer();
gl.BlendFunc(BlendFn::One, BlendFn::One);
gl.Enable(Capability::Blend);
gl.Enable(Capability::DepthTest);
draw_prog.Use();
draw_prog.camera_matrix.Set(
CamMatrixf::Orbiting(
Vec3f(),
27.0,
Degrees(time * 23),
Degrees(SineWave(time / 23.0) * 80)
)
);
cube.Use();
cube.Draw(n*n*n);
gl.Disable(Capability::DepthTest);
gl.Disable(Capability::Blend);
fbo.Unbind();
}
void RenderGlassShadowMap(
const Vec3f& light_position,
const Vec3f& torus_center,
const Mat4f& torus_matrix,
const Mat4f& light_proj_matrix
)
{
glass_shadow_fbo.Bind(Framebuffer::Target::Draw);
gl.Viewport(shadow_tex_side, shadow_tex_side);
const GLfloat clear_color[4] = {1.0f, 1.0f, 1.0f, 0.0f};
gl.ClearColorBuffer(0, clear_color);
transf_prog.camera_matrix.Set(light_proj_matrix);
transf_prog.camera_position.Set(light_position);
transf_prog.light_proj_matrix.Set(light_proj_matrix);
transf_prog.light_position.Set(light_position);
// Render the torus' frame
transf_prog.model_matrix.Set(torus_matrix);
// setup the view clipping plane
Planef clip_plane = Planef::FromPointAndNormal(
torus_center,
Normalized(light_position-torus_center)
);
transf_prog.clip_plane.Set(clip_plane.Equation());
light_pp.Bind();
light_prog.color = Vec3f(0.6f, 0.4f, 0.1f);
gl.Disable(Capability::DepthTest);
gl.Enable(Functionality::ClipDistance, 0);
gl.Enable(Capability::Blend);
for(int c=0; c!=2; ++c)
{
transf_prog.clip_direction.Set((c == 0)?1:-1);
for(int p=3; p>=0; --p)
{
if(p % 2 == 0) gl.CullFace(Face::Front);
else gl.CullFace(Face::Back);
torus.Draw(
[&p](GLuint phase) -> bool
{
if(p == 0 || p == 3)
{
return (phase == 4);
}
else return (phase > 4);
}
);
}
}
gl.Disable(Capability::Blend);
gl.Disable(Functionality::ClipDistance, 0);
gl.Enable(Capability::DepthTest);
}
void BSP(const Mat4f& camera, std::size_t p)
{
assert(p < std::size_t(plane.size()));
// the normal vector of the plane
Vec4f normal(make_plane[p].Normal(), 0.0);
// check if we are seeing the front or the back face
GLfloat sign = ((camera*normal).z() >= 0.0f)? 1.0f: -1.0f;
bool at_leaf = p+1 == plane.size();
gl.Enable(Functionality::ClipDistance, p);
torus_clip_signs[p].Set(-sign);
plane_clip_signs[p].Set(-sign);
if(at_leaf) RenderTorus();
else BSP(camera, p+1);
gl.Disable(Functionality::ClipDistance, p);
RenderPlane(p);
gl.Enable(Functionality::ClipDistance, p);
torus_clip_signs[p].Set(+sign);
plane_clip_signs[p].Set(+sign);
if(at_leaf) RenderTorus();
else BSP(camera, p+1);
gl.Disable(Functionality::ClipDistance, p);
}
void Render(double time)
{
namespace se = oglplus::smart_enums;
gl.Clear().ColorBuffer().DepthBuffer().StencilBuffer();
// make the camera matrix orbiting around the origin
// at radius of 3.5 with elevation between 15 and 90 degrees
Mat4f camera = CamMatrixf::Orbiting(
Vec3f(),
6.5,
Degrees(time * 135),
Degrees(15 + (-SineWave(0.25+time/12.5)+1.0)*0.5*75)
);
ModelMatrixf model = ModelMatrixf::Translation(0.0f, 1.5f, 0.0);
ModelMatrixf identity;
//
SetProgramUniform(prog_norm, "CameraMatrix", camera);
SetProgramUniform(prog_refl, "CameraMatrix", camera);
// draw the plane into the stencil buffer
prog_norm.Use();
gl.Disable(se::Blend());
gl.Disable(se::DepthTest());
gl.Enable(se::StencilTest());
gl.ColorMask(false, false, false, false);
gl.StencilFunc(se::Always(), 1, 1);
gl.StencilOp(se::Keep(), se::Keep(), se::Replace());
Uniform<Mat4f> model_matrix_norm(prog_norm, "ModelMatrix");
model_matrix_norm.Set(identity);
plane.Bind();
gl.DrawArrays(se::TriangleStrip(), 0, 4);
gl.ColorMask(true, true, true, true);
gl.Enable(se::DepthTest());
gl.StencilFunc(se::Equal(), 1, 1);
gl.StencilOp(se::Keep(), se::Keep(), se::Keep());
// draw the torus using the reflection program
prog_refl.Use();
Uniform<Mat4f>(prog_refl, "ModelMatrix").Set(model);
torus.Bind();
torus_instr.Draw(torus_indices);
gl.Disable(se::StencilTest());
prog_norm.Use();
// draw the torus using the normal object program
model_matrix_norm.Set(model);
torus_instr.Draw(torus_indices);
// blend-in the plane
gl.Enable(se::Blend());
gl.BlendEquation(se::Max());
model_matrix_norm.Set(identity);
plane.Bind();
gl.DrawArrays(se::TriangleStrip(), 0, 4);
}
void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer().StencilBuffer();
// make the camera matrix orbiting around the origin
// at radius of 3.5 with elevation between 15 and 90 degrees
camera_matrix.Set(
CamMatrixf::Orbiting(
Vec3f(),
5.0,
Degrees(time * 11),
Degrees(15 + (-SineWave(0.25+time/12.5)+1.0)*0.5*75)
)
);
ModelMatrixf identity;
// make the model transformation matrix
ModelMatrixf model =
ModelMatrixf::Translation(0.0f, 1.5f, 0.0) *
ModelMatrixf::RotationZ(Degrees(time * 43))*
ModelMatrixf::RotationY(Degrees(time * 63))*
ModelMatrixf::RotationX(Degrees(time * 79));
// make the reflection matrix
auto reflection = ModelMatrixf::Reflection(false, true, false);
//
gl.Disable(Capability::Blend);
gl.Disable(Capability::DepthTest);
gl.Enable(Capability::StencilTest);
gl.ColorMask(false, false, false, false);
gl.StencilFunc(CompareFunction::Always, 1, 1);
gl.StencilOp(StencilOp::Keep, StencilOp::Keep, StencilOp::Replace);
gl.Bind(plane);
model_matrix.Set(identity);
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
gl.ColorMask(true, true, true, true);
gl.Enable(Capability::DepthTest);
gl.StencilFunc(CompareFunction::Equal, 1, 1);
gl.StencilOp(StencilOp::Keep, StencilOp::Keep, StencilOp::Keep);
// draw the cube using the reflection program
model_matrix.Set(reflection * model);
gl.Bind(cube);
cube_instr.Draw(cube_indices);
gl.Disable(Capability::StencilTest);
// draw the cube using the normal object program
model_matrix.Set(model);
cube_instr.Draw(cube_indices);
// blend-in the plane
gl.Enable(Capability::Blend);
gl.BlendEquation(BlendEquation::Max);
gl.Bind(plane);
model_matrix.Set(identity);
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
}
BlobExample(const ExampleParams& params)
: blob_prog()
, metal_prog()
, grid(blob_prog, params.quality)
, plane(metal_prog) {
std::srand(234);
for(GLuint i = 0; i != 24; ++i) {
GLuint j = 0, n = 3 + std::rand() % 3;
std::vector<Vec4f> points(n);
GLfloat ball_size = 0.15f * std::rand() / GLfloat(RAND_MAX) + 0.25f;
while(j != n) {
points[j] = Vec4f(
1.2f * std::rand() / GLfloat(RAND_MAX) - 0.6f,
1.2f * std::rand() / GLfloat(RAND_MAX) - 0.6f,
1.2f * std::rand() / GLfloat(RAND_MAX) - 0.6f,
ball_size);
++j;
}
ball_paths.push_back(CubicBezierLoop<Vec4f, double>(points));
}
//
Texture::Active(1);
blob_prog.metaballs.Set(1);
gl.Bound(Texture::Target::_1D, metaballs_tex)
.Filter(TextureFilter::Nearest)
.Wrap(TextureWrap::ClampToEdge)
.Image1D(
0,
PixelDataInternalFormat::RGBA32F,
ball_paths.size(),
0,
PixelDataFormat::RGBA,
PixelDataType::Float,
nullptr);
Texture::Active(2);
metal_prog.metal_tex.Set(2);
gl.Bound(Texture::Target::_2D, metal_tex)
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.Wrap(TextureWrap::Repeat)
.Image2D(images::BrushedMetalUByte(512, 512, 5120, -3, +3, 32, 128))
.GenerateMipmap();
const Vec3f light_position(12.0, 1.0, 8.0);
blob_prog.light_position.Set(light_position);
metal_prog.light_position.Set(light_position);
gl.ClearColor(0.8f, 0.7f, 0.6f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CW);
gl.CullFace(Face::Back);
}
MorphingExample()
: shape(point_prog)
, status(0.0) {
point_prog.color_1 = Vec3f(1.0f, 0.5f, 0.4f);
point_prog.color_2 = Vec3f(1.0f, 0.8f, 0.7f);
gl.ClearColor(0.2f, 0.2f, 0.2f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::ProgramPointSize);
gl.Enable(Capability::Blend);
}
int main() {
sf::ContextSettings set;
set.antialiasingLevel = 8;
sf::Window w(sf::VideoMode(700, 700), "ogl", sf::Style::Default, set);
glewExperimental = true;
glewInit();
Context gl;
gl.ClearColor(0.0, 0.0, 0.0, 1.0);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.Enable(Capability::Blend);
w.setMouseCursorVisible(false);
Pyramid pyramid { w };
bool running = true;
while(running) {
sf::Event e;
while(w.pollEvent(e)){
if(e.type == sf::Event::Closed){ running = false; }
if(e.type == sf::Event::KeyPressed) {
switch(e.key.code) {
case sf::Keyboard::Escape:
running = false;
break;
case sf::Keyboard::W: case sf::Keyboard::Up:
camera.forward();
break;
case sf::Keyboard::A: case sf::Keyboard::Left:
camera.left();
break;
case sf::Keyboard::S: case sf::Keyboard::Down:
camera.back();
break;
case sf::Keyboard::D: case sf::Keyboard::Right:
camera.right();
break;
default:
break;
}
}
if(e.type == sf::Event::MouseMoved) {
//idk
}
}
pyramid.update();
pyramid.draw(gl);
gl.Clear().ColorBuffer().DepthBuffer();
w.display();
}
return 0;
}
ParallaxMapExample()
: prog(make())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
, camera_position(prog, "CameraPosition")
, light_position(prog, "LightPosition")
, shape(
List("Position")("Normal")("Tangent")("TexCoord").Get(),
shapes::Torus(1.0f, 0.5, 72, 48)) {
shape.UseInProgram(prog);
auto tex_image = images::LoadTexture("bricks_color_hmap");
Texture::Active(0);
try {
UniformSampler(prog, "ColorMap").Set(0);
gl.Bound(Texture::Target::_2D, color_tex)
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat)
.Image2D(tex_image)
.GenerateMipmap();
} catch(Error&) {
}
Texture::Active(1);
try {
UniformSampler(prog, "BumpMap").Set(1);
gl.Bound(Texture::Target::_2D, bump_tex)
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat)
.Image2D(
images::NormalMap(tex_image, images::NormalMap::FromAlpha()))
.GenerateMipmap();
} catch(Error&) {
}
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Disable(Capability::CullFace);
gl.Enable(Functionality::ClipDistance, 0);
gl.Enable(Functionality::ClipDistance, 1);
gl.Enable(Functionality::ClipDistance, 2);
}
SubsurfExample(void)
: gl()
, shape("stanford_dragon")
, depth_prog()
, draw_prog()
, depth_vao(shape.VAOForProgram(depth_prog))
, draw_vao(shape.VAOForProgram(draw_prog))
, depth_buffer(draw_prog, 0, 1024)
{
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
gl.PolygonOffset(1.0f, 1.0f);
}
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);
}
LightRayExample(void)
: gl()
, mesh_loader(
mesh_input.stream,
shapes::ObjMesh::LoadingOptions(false).Normals()
), meshes(List("Position")("Normal").Get(), mesh_loader)
, fan_index(mesh_loader.GetMeshIndex("Fan"))
, light_position(0.0, 0.0, -100.0)
, vert_shader()
, mask_prog(vert_shader)
, mask_vao(meshes.VAOForProgram(mask_prog))
, draw_prog(vert_shader)
, draw_vao(meshes.VAOForProgram(draw_prog))
, shadow_tex_unit(0)
, light_tex_unit(1)
{
mesh_input.stream.close();
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
RenderShadowMap(512);
SetupLightMask();
mask_prog.Use();
mask_prog.light_position.Set(light_position);
draw_prog.Use();
draw_prog.light_position.Set(light_position);
gl.ClearColor(1.0f, 1.0f, 1.0f, 0.0f);
}
ObjMeshExample(void)
: gl()
, objects(load_objects())
, depth_prog()
, draw_prog()
, depth_vao(objects.VAOForProgram(depth_prog))
, draw_vao(objects.VAOForProgram(draw_prog))
{
UniformSampler(draw_prog, "DepthTex").Set(0);
Texture::Active(0);
depth_tex.Bind(Texture::Target::Rectangle);
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
}
FlowExample(void)
: gl()
, flow(images::LoadTexture("flow_map"), 1)
, screen(
List("Position")("TexCoord").Get(),
shapes::Screen(),
screen_prog
)
{
Texture::Active(0);
{
auto bound_tex = Bind(background, Texture::Target::_2D);
bound_tex.Image2D(images::LoadTexture("flower_glass"));
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::MirroredRepeat);
bound_tex.WrapT(TextureWrap::MirroredRepeat);
}
screen_prog.background.Set(0);
screen_prog.normal_map.Set(flow.TexUnit());
gl.ClearColor(0.4f, 0.4f, 0.4f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
void Update(double time)
{
gl.Viewport(size, size);
fbo.Bind(Framebuffer::Target::Draw);
Framebuffer::AttachColorTexture(
Framebuffer::Target::Draw,
1,
holder.CurrentHeightMap(),
0
);
Context::ColorBuffer draw_buffs[2] = {
FramebufferColorAttachment::_0,
FramebufferColorAttachment::_1
};
gl.DrawBuffers(draw_buffs);
prog.Use();
prog.hmap_1.Set(holder.HMapUnit1());
prog.hmap_2.Set(holder.HMapUnit2());
prog.time.Set(time);
screen.Use();
gl.Disable(Capability::DepthTest);
screen.Draw();
gl.Enable(Capability::DepthTest);
holder.Swap();
}
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);
}
CubeExample(void)
: n(16)
, screen_prog()
, draw_prog()
, screen(List("Position")("TexCoord").Get(), shapes::Screen(), screen_prog)
, cube(List("Position").Get(), shapes::Cube(), draw_prog)
{
draw_prog.Use();
UniformBlock(draw_prog, "OffsetBlock").Binding(0);
cube_pos<< BufferIndexedTarget::Uniform << 0
<< BufferUsage::StaticDraw
<< OffsetData(n);
ProgramUniformSampler(screen_prog, "Palette").Set(0);
Texture::Active(0);
palette << Texture::Target::_1D
<< TextureFilter::Nearest
<< TextureWrap::ClampToEdge
<< images::LinearGradient(
16,
Vec3f(0, 0, 0),
std::map<GLfloat, Vec3f>({
{ 0.0/16.0, Vec3f(0.0, 0.0, 0.0)},
{ 1.0/16.0, Vec3f(0.5, 0.0, 1.0)},
{ 3.0/16.0, Vec3f(0.0, 0.0, 1.0)},
{ 6.0/16.0, Vec3f(0.0, 0.6, 0.6)},
{ 8.0/16.0, Vec3f(0.0, 1.0, 0.0)},
{ 11.0/16.0, Vec3f(0.6, 0.6, 0.0)},
{ 13.0/16.0, Vec3f(1.0, 0.1, 0.0)},
{ 16.0/16.0, Vec3f(0.7, 0.0, 0.0)}
})
);
ProgramUniformSampler(screen_prog, "Tex").Set(1);
Texture::Active(1);
tex << Texture::Target::Rectangle
<< TextureMinFilter::Nearest
<< TextureMagFilter::Nearest
<< TextureWrap::ClampToEdge
<< images::ImageSpec(
64, 64,
Format::Red,
InternalFormat::R8,
DataType::UnsignedByte
);
rbo << Renderbuffer::Target::Renderbuffer
<< images::ImageSpec(64, 64, InternalFormat::DepthComponent);
fbo << Framebuffer::Target::Draw
<< FramebufferAttachment::Color << tex
<< FramebufferAttachment::Depth << rbo
<< FramebufferComplete();
gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::CullFace);
}
void ShadowMapRenderer::BlurShadowMap()
{
using namespace oglplus;
static Context gl;
auto &prog = BlurShader();
CurrentProgram<BlurProgram>(prog);
// horizontal blur
blurFramebuffer.Bind(FramebufferTarget::Draw);
gl.Disable(Capability::DepthTest);
// active shadow to be read
shadowMap.Active(0);
shadowMap.Bind(TextureTarget::_2D);
// update uniform
prog.source.Set(0);
prog.blurDirection.Set(glm::vec2(1.0f / shadowMapSize.x * blurScale, 0.0f));
prog.blurType.Set(blurQuality);
gl.Clear().DepthBuffer().ColorBuffer();
fsQuad.DrawElements();
// blur vertically
shadowFramebuffer.Bind(FramebufferTarget::Draw);
// active shadow to be read
blurShadow.Bind(TextureTarget::_2D);
// update uniform
prog.source.Set(0);
prog.blurDirection.Set(glm::vec2(0.0f, 1.0f / shadowMapSize.y * blurScale));
prog.blurType.Set(blurQuality);
gl.Clear().DepthBuffer().ColorBuffer();
fsQuad.DrawElements();
gl.Enable(Capability::DepthTest);
}
void RenderFrameShadowMap(
const Vec3f& light_position,
const Mat4f& torus_matrix,
const Mat4f& light_proj_matrix
)
{
frame_shadow_fbo.Bind(Framebuffer::Target::Draw);
gl.Viewport(shadow_tex_side, shadow_tex_side);
gl.ClearDepthBuffer(1.0f);
gl.CullFace(Face::Back);
transf_prog.camera_matrix.Set(light_proj_matrix);
transf_prog.camera_position.Set(light_position);
// Render the torus' frame
transf_prog.model_matrix.Set(torus_matrix);
shadow_pp.Bind();
gl.Enable(Capability::PolygonOffsetFill);
torus.Draw(
[](GLuint phase) -> bool
{
return (phase <= 3);
}
);
gl.Disable(Capability::PolygonOffsetFill);
}
TorusExample(void)
: make_torus(1.0, 0.5, 36, 24)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, prog(make_prog())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
Uniform<Vec4f>(prog, "ClipPlane").Set(0.f, 0.f, 1.f, 0.f);
// bind the VAO for the torus
torus.Bind();
// bind the VBO for the torus vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the torus UV-coordinates
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.TexCoordinates(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
//
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.FrontFace(make_torus.FaceWinding());
gl.Enable(Capability::DepthTest);
gl.Enable(Functionality::ClipDistance, 0);
}
void Use(void)
{
gl.ClearDepth(1.0f);
gl.ClearColor(0.9f, 0.4f, 0.4f, 1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
fbo.Bind(Framebuffer::Target::Draw);
gl.Viewport(tex_side, tex_side);
prog.Use();
shape.Use();
projection_matrix.Set(CamMatrixf::PerspectiveX(Degrees(48), 1.0, 1, 100));
}
void Use(void)
{
gl.ClearDepth(1.0f);
gl.ClearColor(0.8f, 0.8f, 0.8f, 0.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
dfb.Bind(Framebuffer::Target::Draw);
gl.Viewport(width, height);
prog.Use();
cube.Use();
SetProjection();
}
void operator()(const Particles& particles)
{
gl.Enable(Capability::Blend);
gl.Bind(vao);
gl.Use(prog);
gl.DrawElements(PrimitiveType::Points, particles.Count(), (GLuint*)0);
gl.Disable(Capability::Blend);
}
void RenderPlane(std::size_t p)
{
gl.Enable(Capability::Blend);
plane_prog.Use();
plane_normal.Set(make_plane[p].Normal());
plane[p].Bind();
plane_instr.Draw(plane_indices);
gl.Disable(Capability::Blend);
}
SphereExample(void)
: vs(make_vs())
, proton(vs,make_fs(fs_proton()))
, neutron(vs,make_fs(fs_neutron()))
, electron(vs,make_fs(fs_electron()))
{
gl.ClearColor(0.3f, 0.3f, 0.3f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
void GIDeferredRenderer::Render()
{
using namespace oglplus;
static Context gl;
static auto &camera = Camera::Active();
static auto &scene = Scene::Active();
static auto &info = Window().Info();
if (!camera || !scene || !scene->IsLoaded() || VoxelizerRenderer::ShowVoxels)
{
return;
}
SetAsActive();
// bind g buffer for writing
geometryBuffer.Bind(FramebufferTarget::Draw);
gl.ColorMask(true, true, true, true);
gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.Viewport(info.framebufferWidth, info.framebufferHeight);
gl.Clear().ColorBuffer().DepthBuffer();
// activate geometry pass shader program
CurrentProgram<GeometryProgram>(GeometryPass());
// rendering and GL flags
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Disable(Capability::Blend);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CCW);
gl.CullFace(Face::Back);
camera->DoFrustumCulling(true);
// draw whole scene tree from root node
scene->rootNode->DrawList();
// start light pass
DefaultFramebuffer().Bind(FramebufferTarget::Draw);
gl.ColorMask(true, true, true, true);
gl.Viewport(info.framebufferWidth, info.framebufferHeight);
gl.Clear().ColorBuffer().DepthBuffer();
CurrentProgram<LightingProgram>(LightingPass());
// pass light info and texture locations for final light pass
SetLightPassUniforms();
// draw the result onto a fullscreen quad
fsQuad.DrawElements();
}
LiquidExample(const ExampleParams& params)
: liquid_prog()
, grid(liquid_prog, params.quality)
, grid_repeat(1 + params.quality*2)
{
Texture::Active(0);
{
auto image = images::NewtonFractal(
256, 256,
Vec3f(0.1f, 0.1f, 0.1f),
Vec3f(1.0f, 1.0f, 1.0f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X4Minus1(),
images::NewtonFractal::DefaultMixer()
);
auto bound_tex = oglplus::Context::Bound(
Texture::Target::CubeMap,
env_map
);
for(int i=0; i!=6; ++i)
Texture::ImageCM(i, image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
}
ProgramUniformSampler(liquid_prog, "EnvMap").Set(0);
const Vec3f light_position(12.0, 1.0, 8.0);
liquid_prog.light_position.Set(light_position);
gl.ClearColor(0.7f, 0.65f, 0.55f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CW);
gl.CullFace(Face::Back);
}
SubsurfExample(void)
: gl()
, shape("stanford_dragon", data_prog)
, screen(List("Position").Get(), shapes::Screen(), draw_prog)
, data_buffer(draw_prog, 0, 800, 600)
{
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.ClearDepth(1.0f);
}