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);
}
void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer();
//
camera_matrix.Set(
CamMatrixf::Orbiting(
Vec3f(),
3.0f,
Degrees(time * 50),
Degrees(SineWave(time / 16.0) * 80)
)
);
// the model matrix
model_matrix.Set(
ModelMatrixf::RotationY(Degrees(time * 25))
);
// draw 36 instances of the cube
// first the back faces
gl.CullFace(Face::Front);
front_facing.Set(0);
cube_instr.Draw(cube_indices, inst_count);
// then the front faces
gl.CullFace(Face::Back);
front_facing.Set(1);
cube_instr.Draw(cube_indices, inst_count);
}
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);
}
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 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);
}
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);
}
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();
}
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 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);
}
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);
}
void Render(double time)
{
gl.ClearDepth(0.0f);
gl.Clear().DepthBuffer();
auto camera =
CamMatrixf::Orbiting(
objects.BoundingSphere().Center(),
objects.BoundingSphere().Radius()*2.8,
FullCircles(time / 19.0),
Degrees(SineWave(time / 17.0) * 90)
);
depth_prog.Use();
gl.DepthFunc(CompareFn::Greater);
gl.CullFace(Face::Front);
depth_prog.camera_matrix.Set(camera);
depth_prog.model_matrix.Set(Mat4f());
objects.Draw();
Texture::CopyImage2D(
Texture::Target::Rectangle,
0,
PixelDataInternalFormat::DepthComponent,
0, 0,
width,
height,
0
);
gl.ClearDepth(1.0f);
gl.Clear().ColorBuffer().DepthBuffer();
draw_prog.Use();
gl.DepthFunc(CompareFn::Less);
gl.CullFace(Face::Back);
draw_prog.camera_matrix.Set(camera);
draw_prog.model_matrix.Set(Mat4f());
objects.Draw();
}
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);
}
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 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 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);
}
CubeExample(void)
: cube(
List("Position")("Normal")("TexCoord").Get(),
shapes::Cube(),
cube_prog
)
{
// setup the texture
{
GLuint tex_side = 512;
auto image = images::NewtonFractal(
tex_side, tex_side,
Vec3f(0.2f, 0.1f, 0.4f),
Vec3f(0.8f, 0.8f, 1.0f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X4Minus1(),
images::NewtonFractal::DefaultMixer()
);
gl.Bound(Texture::Target::_2D, cube_tex)
.Image2D(image)
.GenerateMipmap()
.BorderColor(Vec4f(0.8f, 0.8f, 1.0f, 1.0f))
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat);
}
cube_prog.cube_tex = 0;
cube_prog.light_position.Set(4.0f, 4.0f, -8.0f);
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
}
void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer();
//
Vec3f lightPos(-1.0f, 2.0f, 2.0f);
lightPos *= (1.0f - SineWave(time/5.0f)*0.4f);
light_pos.Set(lightPos);
tex_projection_matrix.Set(
CamMatrixf::PerspectiveX(Degrees(15), 1.0, 1, 20) *
CamMatrixf::LookingAt(lightPos, Vec3f())
);
// set the model matrix
model_matrix.Set(
ModelMatrixf::RotationY(FullCircles(time * 0.1))
);
cube.Bind();
gl.CullFace(Face::Front);
cube_instr.Draw(cube_indices);
}
TorusExample(void)
: make_torus(1.0, 0.5, 72, 48)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source and compile it
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"out vec2 vertTexCoord;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"uniform sampler2D TexUnit;"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = sqrt(length(vertLight));"
" float d = l > 0? dot("
" vertNormal, "
" normalize(vertLight)"
" ) / l : 0.0;"
" float i = 0.2 + 3.2*max(d, 0.0);"
" fragColor = texture(TexUnit, vertTexCoord)*i;"
"}"
).Compile();
// attach the shaders to the program
prog.AttachShader(vs).AttachShader(fs);
// link and use it
prog.Link().Use();
// 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
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the torus normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the torus texture 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
VertexAttribArray attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
Texture::Target tex_tgt = Texture::Target::_2D;
tex.Bind(tex_tgt);
{
GLuint s = 256;
std::vector<GLubyte> tex_data(s*s);
for(GLuint v=0;v!=s;++v)
for(GLuint u=0;u!=s;++u)
tex_data[v*s+u] = rand() % 0x100;
Texture::Image2D(
tex_tgt,
0,
PixelDataInternalFormat::Red,
s, s,
0,
PixelDataFormat::Red,
PixelDataType::UnsignedByte,
tex_data.data()
);
Texture::MinFilter(tex_tgt, TextureMinFilter::Linear);
Texture::MagFilter(tex_tgt, TextureMagFilter::Linear);
Texture::WrapS(tex_tgt, TextureWrap::Repeat);
Texture::WrapT(tex_tgt, TextureWrap::Repeat);
Texture::SwizzleG(tex_tgt, TextureSwizzle::Red);
Texture::SwizzleB(tex_tgt, TextureSwizzle::Red);
}
// typechecked uniform with exact data type
// on compilers supporting strongly typed enums
// you can use:
//Typechecked<Uniform<SLtoCpp<SLDataType::Sampler2D>>>(prog, "TexUnit").Set(0);
// without strongly typed enums you need to do:
typedef SLtoCpp<OGLPLUS_CONST_ENUM_VALUE(SLDataType::Sampler2D)> GLSLsampler2D;
Typechecked<Uniform<GLSLsampler2D>>(prog, "TexUnit").Set(0);
//
Uniform<Vec3f>(prog, "LightPos").Set(4.0f, 4.0f, -8.0f);
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_torus.FaceWinding());
gl.CullFace(Face::Back);
}
CubeMapExample(void)
: make_shape(4)
, shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"out vec3 vertNormal;"
"out vec3 vertTexCoord;"
"out vec3 vertLightDir;"
"out vec3 vertViewDir;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vec3 Normal = Position.xyz;"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertTexCoord = Normal;"
" vertLightDir = LightPos - gl_Position.xyz;"
" vertViewDir = (vec4(0.0, 0.0, 1.0, 1.0)*CameraMatrix).xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
vs.Compile();
gs.Source(
"#version 330\n"
"layout (triangles) in;"
"layout (triangle_strip, max_vertices = 3) out;"
"in vec3 vertNormal[3];"
"in vec3 vertTexCoord[3];"
"in vec3 vertLightDir[3];"
"in vec3 vertViewDir[3];"
"out vec3 geomNormal;"
"out vec3 geomTexCoord;"
"out vec3 geomLightDir;"
"out vec3 geomLightRefl;"
"out vec3 geomViewDir;"
"void main(void)"
"{"
" vec3 FaceNormal = 0.333333*("
" vertNormal[0]+"
" vertNormal[1]+"
" vertNormal[2] "
" );"
" for(int v=0; v!=3; ++v)"
" {"
" gl_Position = gl_in[v].gl_Position;"
" geomNormal = 0.5*(vertNormal[v]+FaceNormal);"
" geomTexCoord = vertTexCoord[v];"
" geomLightDir = vertLightDir[v];"
" geomLightRefl = reflect("
" -normalize(geomLightDir),"
" normalize(FaceNormal)"
" );"
" geomViewDir = vertViewDir[v];"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
);
gs.Compile();
fs.Source(
"#version 330\n"
"uniform samplerCube TexUnit;"
"in vec3 geomNormal;"
"in vec3 geomTexCoord;"
"in vec3 geomLightDir;"
"in vec3 geomLightRefl;"
"in vec3 geomViewDir;"
"out vec3 fragColor;"
"void main(void)"
"{"
" vec3 lt = vec3(1.0, 1.0, 1.0);"
" vec3 tex = texture(TexUnit, geomTexCoord).rgb;"
" float d = dot("
" normalize(geomNormal), "
" normalize(geomLightDir)"
" );"
" float s = dot("
" normalize(geomLightRefl),"
" normalize(geomViewDir)"
" );"
" float b = 1.0-sqrt(max(dot("
" normalize(geomNormal),"
" normalize(geomViewDir)"
" ), 0.0));"
" float ea = clamp(tex.b*(-d+0.2), 0.0, 1.0);"
" float sr = 1.0-tex.b*0.8;"
" fragColor = "
" tex * (0.3*ea + 0.6*b + 0.8*max(d, 0.0)) + "
" (tex+lt) * 0.8*sr*pow(clamp(s+0.05, 0.0, 1.0), 32);"
"}"
);
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(gs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the shape
shape.Bind();
positions.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
{
auto bound_tex = Bind(tex, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
const char* tex_name[6] = {
"cube_0_right",
"cube_1_left",
"cube_2_top",
"cube_3_bottom",
"cube_4_front",
"cube_5_back"
};
for(GLuint i=0; i!=6; ++i)
{
Texture::Image2D(
Texture::CubeMapFace(i),
images::LoadTexture(tex_name[i], false, true)
);
}
}
UniformSampler(prog, "TexUnit").Set(0);
//
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(3.0f, 5.0f, 4.0f));
//
gl.ClearColor(0.05f, 0.2f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
gl.CullFace(Face::Back);
}
void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer();
//
auto camera = CamMatrixf::Orbiting(
Vec3f(),
5.5,
FullCircles(time / 10.0),
Degrees(45.0 + SineWave(time / 7.0)*30.0)
);
// Render the plane
plane_prog.Use();
plane_camera_matrix.Set(camera);
plane_model_matrix.Set(
ModelMatrixf::Translation(0.0f, -1.1f, 0.0f)
);
gl.Bind(plane);
plane_instr.Draw(plane_indices);
// Render the shape
shape_prog.Use();
auto clip_plane = Planef::FromNormal(Vec3f(Data(camera.Row(2)), 3));
shape_clip_plane.Set(clip_plane.Equation());
shape_camera_matrix.Set(camera);
shape_model_matrix.Set(
ModelMatrixf::RotationX(FullCircles(time / 12.0))
);
gl.Bind(shape);
gl.Enable(Capability::CullFace);
gl.Enable(Functionality::ClipDistance, 0);
gl.FrontFace(make_shape.FaceWinding());
GLfloat clip_dirs[2] = {-1.0f, 1.0f};
Face facing_dirs[2] = {Face::Front, Face::Back};
for(int c=0; c!=2; ++c)
{
shape_clip_direction.Set(clip_dirs[c]);
for(int f=0; f!=2; ++f)
{
Texture::CopyImage2D(
Texture::Target::_2D,
0,
PixelDataInternalFormat::RGB,
tex_side == width ? 0 : (width - tex_side) / 2,
tex_side == height? 0 : (height- tex_side) / 2,
tex_side, tex_side,
0
);
gl.CullFace(facing_dirs[f]);
shape_instr.Draw(shape_indices);
}
}
gl.Disable(Functionality::ClipDistance, 0);
gl.Disable(Capability::CullFace);
}
TorusExample(void)
: make_torus(1.0, 0.5, 72, 48)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source and compile it
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"void main(void)"
"{"
" vertNormal = mat3(CameraMatrix)*mat3(ModelMatrix)*Normal;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"uniform int ColorCount;"
"uniform vec4 Color[8];"
"in vec3 vertNormal;"
"vec3 ViewDir = vec3(0.0, 0.0, 1.0);"
"vec3 TopDir = vec3(0.0, 1.0, 0.0);"
"out vec4 fragColor;"
"void main(void)"
"{"
" float k = dot(vertNormal, ViewDir);"
" vec3 reflDir = 2.0*k*vertNormal - ViewDir;"
" float a = dot(reflDir, TopDir);"
" vec3 reflColor;"
" for(int i = 0; i != (ColorCount - 1); ++i)"
" {"
" if(a<Color[i].a && a>=Color[i+1].a)"
" {"
" float m = "
" (a - Color[i].a)/"
" (Color[i+1].a-Color[i].a);"
" reflColor = mix("
" Color[i].rgb,"
" Color[i+1].rgb,"
" m"
" );"
" break;"
" }"
" }"
" float i = max(dot(vertNormal, TopDir), 0.0);"
" vec3 diffColor = vec3(i, i, i);"
" fragColor = vec4("
" mix(reflColor, diffColor, 0.3 + i*0.7),"
" 1.0"
" );"
"}"
).Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link().Use();
// 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
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float).Enable();
}
// bind the VBO for the torus normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "Normal");
attr.Setup(n_per_vertex, DataType::Float).Enable();
}
// setup the color gradient
Uniform<GLint>(prog, "ColorCount").Set(8);
Uniform<Vec4f> color(prog, "Color");
color[0].Set(1.0f, 1.0f, 0.9f, 1.00f);
color[1].Set(1.0f, 0.9f, 0.8f, 0.97f);
color[2].Set(0.9f, 0.7f, 0.5f, 0.95f);
color[3].Set(0.5f, 0.5f, 1.0f, 0.95f);
color[4].Set(0.2f, 0.2f, 0.7f, 0.00f);
color[5].Set(0.1f, 0.1f, 0.1f, 0.00f);
color[6].Set(0.2f, 0.2f, 0.2f,-0.10f);
color[7].Set(0.5f, 0.5f, 0.5f,-1.00f);
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_torus.FaceWinding());
gl.CullFace(Face::Back);
}
void Render(double time) {
gl.Clear().ColorBuffer().DepthBuffer().StencilBuffer();
auto camera = CamMatrixf::Orbiting(
Vec3f(),
9.0,
FullCircles(time * 0.1),
Degrees(15 + (-SineWave(0.25 + time / 12.5) + 1.0) * 0.5 * 75));
ModelMatrixf identity;
ModelMatrixf model =
ModelMatrixf::Translation(0.0f, 2.5f, 0.0) *
ModelMatrixf::RotationA(
Vec3f(1.0f, 1.0f, 1.0f), FullCircles(time * 0.2));
gl.CullFace(Face::Back);
gl.ColorMask(true, true, true, true);
gl.DepthMask(true);
gl.Disable(Capability::StencilTest);
object_prog.Use();
object_camera_matrix.Set(camera);
object_light_mult.Set(0.2f);
object_model_matrix.Set(identity);
plane.Bind();
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
object_model_matrix.Set(model);
torus.Bind();
torus_instr.Draw(torus_indices);
gl.ColorMask(false, false, false, false);
gl.DepthMask(false);
gl.Enable(Capability::StencilTest);
gl.StencilFunc(CompareFunction::Always, 0);
gl.StencilOpSeparate(
Face::Front, StencilOp::Keep, StencilOp::Keep, StencilOp::Incr);
gl.StencilOpSeparate(
Face::Back, StencilOp::Keep, StencilOp::Keep, StencilOp::Decr);
shadow_prog.Use();
shadow_camera_matrix.Set(camera);
shadow_model_matrix.Set(model);
gl.CullFace(Face::Back);
torus_instr.Draw(torus_indices);
gl.CullFace(Face::Front);
torus_instr.Draw(torus_indices);
gl.CullFace(Face::Back);
gl.ColorMask(true, true, true, true);
gl.DepthMask(true);
gl.Clear().DepthBuffer();
gl.StencilFunc(CompareFunction::Equal, 0);
gl.StencilOp(StencilOp::Keep, StencilOp::Keep, StencilOp::Keep);
object_prog.Use();
object_light_mult.Set(2.5);
object_model_matrix.Set(identity);
object_color.Set(0.8f, 0.7f, 0.4f);
plane.Bind();
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
object_model_matrix.Set(model);
object_color.Set(0.9f, 0.8f, 0.1f);
torus.Bind();
torus_instr.Draw(torus_indices);
}
Test01(void)
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 projectionMatrix, cameraMatrix, modelMatrix;"
"in vec4 vertex;"
"in vec3 normal;"
"in vec3 tangent;"
"in vec2 texcoord;"
"out vec3 fragLight;"
"out vec2 fragTex;"
"out mat3 normalMatrix;"
"uniform vec3 lightPos;"
"void main(void)"
"{"
" vec3 fragNormal = ("
" modelMatrix *"
" vec4(normal, 0.0)"
" ).xyz;"
" vec3 fragTangent = ("
" modelMatrix *"
" vec4(tangent, 0.0)"
" ).xyz;"
" normalMatrix[0] = fragTangent;"
" normalMatrix[1] = cross(fragNormal, fragTangent);"
" normalMatrix[2] = fragNormal;"
" fragLight = ("
" vec4(lightPos, 0.0)-"
" modelMatrix*vertex"
" ).xyz;"
" fragTex = texcoord;"
" gl_Position = "
" projectionMatrix *"
" cameraMatrix *"
" modelMatrix *"
" vertex;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform sampler2D colorTex, normalTex;"
"in vec3 fragLight;"
"in vec2 fragTex;"
"in mat3 normalMatrix;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float s = 5.0;"
" float l = length(fragLight);"
" vec3 n = texture2D(normalTex, fragTex*s).xyz;"
" vec3 finalNormal = normalMatrix * n;"
" float d = (l != 0.0)?"
" dot(fragLight, finalNormal)/l:"
" 0.0;"
" float i = 0.1 + 2.5*clamp(d, 0.0, 1.0);"
" vec4 t = texture2D(colorTex, fragTex*s);"
" fragColor = vec4(t.rgb*i, 1.0);"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the shape
vao.Bind();
{
std::vector<GLfloat> data;
GLuint n_per_vertex = shape.Positions(data);
Bind(verts, Buffer::Target::Array).Data(data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "vertex");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
{
std::vector<GLfloat> data;
GLuint n_per_vertex = shape.Normals(data);
Bind(normals, Buffer::Target::Array).Data(data);
// setup the vertex attribs array for the normals
VertexAttribArray attr(prog, "normal");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
{
std::vector<GLfloat> data;
GLuint n_per_vertex = shape.Tangents(data);
Bind(tangents, Buffer::Target::Array).Data(data);
VertexAttribArray attr(prog, "tangent");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
// bind the VBO for the shape tex-coords
{
std::vector<GLfloat> data;
GLuint n_per_vertex = shape.TexCoordinates(data);
Bind(texcoords, Buffer::Target::Array).Data(data);
//
VertexAttribArray attr(prog, "texcoord");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
// setup the textures
{
Texture::Active(0);
UniformSampler(prog, "colorTex").Set(0);
auto bound_tex = Bind(color_tex, Texture::Target::_2D);
bound_tex.Image2D(images::LoadTexture("stones"));
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::Repeat);
bound_tex.WrapT(TextureWrap::Repeat);
}
{
Texture::Active(1);
UniformSampler(prog, "normalTex").Set(1);
auto bound_tex = Bind(normal_tex, Texture::Target::_2D);
bound_tex.Image2D(
images::NormalMap(images::LoadTexture("stones-hmap"))
);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::Repeat);
bound_tex.WrapT(TextureWrap::Repeat);
}
Uniform<Mat4f>(prog, "projectionMatrix").Set(
CamMatrixf::Perspective(Degrees(24), 1.25, 1, 100)
);
//
VertexArray::Unbind();
gl.ClearColor(0.3f, 0.3f, 0.3f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
//
gl.FrontFace(shape.FaceWinding());
gl.CullFace(Face::Back);
gl.Enable(Capability::CullFace);
}
LandscapeExample(void)
: grid_side(128)
, make_plane(
Vec3f(0.0f, 0.0f, 0.0f),
Vec3f(9.0f, 0.0f, 0.0f),
Vec3f(0.0f, 0.0f,-9.0f),
grid_side*3, grid_side*3
), plane_instr(make_plane.Instructions())
, plane_indices(make_plane.Indices())
, light_pos(prog, "LightPos")
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, light_path(
ListOf<Vec3f>
(Vec3f(-3.0f, 2.0f, -3.5f))
(Vec3f( 0.0f, 5.0f, 0.5f))
(Vec3f( 3.0f, 3.0f, 3.0f))
(Vec3f( 3.0f, 3.0f, -3.0f))
(Vec3f( 0.0f, 5.0f, 0.5f))
(Vec3f(-3.2f, 2.0f, 3.0f))
.Get()
)
{
VertexShader vs;
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"uniform sampler2D TexUnit;"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec3 vertLight;"
"out vec3 vertNormal;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = Position;"
" float o = 0.0;"
" float s[9];"
" int k=0;"
" for(int y=-1; y!=2; ++y)"
" for(int x=-1; x!=2; ++x)"
" {"
" s[k] = sqrt(texture("
" TexUnit, "
" TexCoord*3.0+"
" vec2(x, y)/128.0"
" ).r);"
" o += s[k++];"
" }"
" gl_Position.y += o*0.5;"
" vec3 c = vec3( 0.0, s[4], 0.0);"
" float d = 1.0/32.0;"
" vertNormal = normalize("
" cross("
" vec3( 0.0, s[1], -d) - c,"
" vec3( -d, s[3], 0.0) - c"
" )+"
" cross("
" vec3( d, s[5], 0.0) - c,"
" vec3( 0.0, s[1], -d) - c"
" )+"
" cross("
" vec3( 0.0, s[7], d) - c,"
" vec3( d, s[5], 0.0) - c"
" )+"
" cross("
" vec3( -d, s[3], 0.0) - c,"
" vec3( 0.0, s[7], d) - c"
" )"
" );"
" vertLight = LightPos - gl_Position.xyz;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" gl_Position;"
"}"
);
vs.Compile();
FragmentShader fs;
fs.Source(
"#version 330\n"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = length(vertLight);"
" float d = l > 0? dot("
" normalize(vertNormal), "
" normalize(vertLight)"
" ) / l : 0.0;"
" float i = 0.1 + 1.2*max(d, 0.0) + 4.2*pow(d, 2.0);"
" fragColor = vec4(i*0.7, i*0.7, i*0.3, 1.0);"
"}"
);
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the plane
plane.Bind();
// bind the VBO for the plane vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_plane.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the plane texture coordinates
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_plane.TexCoordinates(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
Texture::Target tex_tgt = Texture::Target::_2D;
tex.Bind(tex_tgt);
{
auto image = images::NewtonFractal(
grid_side, grid_side,
Vec3f(0.0f, 0.1f, 0.2f),
Vec3f(1.0f, 0.8f, 0.9f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X3Minus1(),
images::NewtonFractal::DefaultMixer()
);
Texture::Image2D(tex_tgt, image);
Texture::MinFilter(tex_tgt, TextureMinFilter::Linear);
Texture::MagFilter(tex_tgt, TextureMagFilter::Linear);
Texture::WrapS(tex_tgt, TextureWrap::MirroredRepeat);
Texture::WrapT(tex_tgt, TextureWrap::MirroredRepeat);
}
//
UniformSampler(prog, "TexUnit").Set(0);
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_plane.FaceWinding());
gl.CullFace(Face::Back);
}
void RenderImage(
double time,
const Vec3f& torus_center,
const Mat4f& torus_matrix,
const Mat4f& light_proj_matrix
)
{
// this is going into the on-screen framebuffer
DefaultFramebuffer().Bind(Framebuffer::Target::Draw);
gl.ClearColor(0.6f, 0.6f, 0.5f, 0.0f);
gl.Viewport(width, height);
gl.Clear().ColorBuffer().DepthBuffer();
gl.CullFace(Face::Back);
//
transf_prog.light_proj_matrix.Set(light_proj_matrix);
Mat4f perspective = CamMatrixf::PerspectiveX(
Degrees(60),
float(width)/height,
1, 60
);
// setup the camera
Vec3f camera_target(0.0f, 0.8f, 0.0f);
auto camera = CamMatrixf::Orbiting(
camera_target,
GLfloat(8.0 - SineWave(time / 15.0)*3.0),
FullCircles(time / 24.0),
Degrees(45 + SineWave(time / 20.0) * 40)
);
Vec3f camera_position = camera.Position();
transf_prog.camera_matrix.Set(perspective*camera);
transf_prog.camera_position.Set(camera_position);
// setup the view clipping plane
Planef clip_plane = Planef::FromPointAndNormal(
torus_center,
Normalized(camera_position-torus_center)
);
metal_pp.Bind();
// Render the plane
transf_prog.model_matrix = ModelMatrixf();
transf_prog.texture_matrix.Set(Mat2f(Vec2f(9.0f,0.0f), Vec2f(0.0f,9.0f)));
metal_prog.color_1 = Vec3f(1.0f, 0.9f, 0.8f);
metal_prog.color_2 = Vec3f(0.9f, 0.8f, 0.6f);
metal_prog.with_glass_shadow = 1;
plane.Draw([](GLuint) -> bool {return true;});
// Render the torus
transf_prog.model_matrix.Set(torus_matrix);
transf_prog.texture_matrix.Set(Mat2f(Vec2f(16.0f,0.0f), Vec2f(0.0f, 4.0f)));
metal_prog.metal_tex.Set(0);
metal_prog.color_1 = Vec3f(0.9f, 0.9f, 0.9f);
metal_prog.color_2 = Vec3f(0.3f, 0.3f, 0.3f);
metal_prog.with_glass_shadow = 0;
// the metal-part
torus.Draw(
[](GLuint phase) -> bool
{
return (phase <= 3);
}
);
// now the glass part
glass_pp.Bind();
glass_prog.color = Vec3f(0.6f, 0.4f, 0.1f);
gl.Enable(Functionality::ClipDistance, 0);
gl.Enable(Capability::Blend);
transf_prog.clip_plane.Set(clip_plane.Equation());
for(int c=0; c!=2; ++c)
{
transf_prog.clip_direction.Set((c == 0)?-1:1);
for(int p=0; p!=4; ++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);
}
void RenderImage(
double time,
const Mat4f& torus_matrix,
const Mat4f& light_proj_matrix
)
{
// this is going into the on-screen framebuffer
DefaultFramebuffer().Bind(Framebuffer::Target::Draw);
gl.ClearColor(1.0f, 0.9f, 0.8f, 0.0f);
gl.Viewport(width, height);
gl.Clear().ColorBuffer().DepthBuffer();
gl.CullFace(Face::Back);
//
transf_prog.light_proj_matrix.Set(light_proj_matrix);
Mat4f perspective = CamMatrixf::PerspectiveX(
Degrees(60),
float(width)/height,
1, 60
);
// setup the camera
Vec3f camera_target(0.0f, 0.8f, 0.0f);
auto camera = CamMatrixf::Orbiting(
camera_target,
GLfloat(7.0 - SineWave(time / 14.0)*3.0),
FullCircles(time / 26.0),
Degrees(45 + SineWave(time / 17.0) * 40)
);
Vec3f camera_position = camera.Position();
transf_prog.camera_matrix.Set(perspective*camera);
transf_prog.camera_position.Set(camera_position);
// render into the depth buffer
shadow_pp.Bind();
gl.Enable(Capability::PolygonOffsetFill);
gl.ColorMask(false, false, false, false);
transf_prog.model_matrix = ModelMatrixf();
plane.Draw();
transf_prog.model_matrix.Set(torus_matrix);
torus.Draw();
gl.ColorMask(true, true, true, true);
gl.Disable(Capability::PolygonOffsetFill);
gl.Enable(Capability::Blend);
gl.Disable(Capability::Blend);
// render into the color buffer
sketch_pp.Bind();
gl.Enable(Capability::Blend);
transf_prog.model_matrix = ModelMatrixf();
transf_prog.texture_matrix.Set(Mat2f(Vec2f(3.0, 0.0), Vec2f(0.0, 3.0)));
plane.Draw();
transf_prog.model_matrix.Set(torus_matrix);
transf_prog.texture_matrix.Set(Mat2f(Vec2f(8.0, 0.0), Vec2f(0.0, 2.0)));
torus.Draw([](GLuint phase) -> bool { return phase < 4; });
transf_prog.texture_matrix.Set(Mat2f(Vec2f(0.0, 2.0), Vec2f(8.0, 0.0)));
torus.Draw([](GLuint phase) -> bool { return phase >= 4; });
// render the edges
line_pp.Bind();
transf_prog.model_matrix = ModelMatrixf();
plane.DrawEdges();
transf_prog.model_matrix.Set(torus_matrix);
torus.DrawEdges();
gl.Disable(Capability::Blend);
}
TorusExample(void)
: make_torus(1.0, 0.5, 72, 48)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source and compile it
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"void main(void)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"in vec3 vertNormal;"
"out vec4 fragColor;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" float intensity = 2.0 * max("
" dot(vertNormal, LightPos)/"
" length(LightPos),"
" 0.0"
" );"
" if(!gl_FrontFacing)"
" fragColor = vec4(0.0, 0.0, 0.0, 1.0);"
" else if(intensity > 0.9)"
" fragColor = vec4(1.0, 0.9, 0.8, 1.0);"
" else if(intensity > 0.1)"
" fragColor = vec4(0.7, 0.6, 0.4, 1.0);"
" else"
" fragColor = vec4(0.3, 0.2, 0.1, 1.0);"
"}"
).Compile();
// attach the shaders to the program
prog << vs << fs;
// link and use it
prog.Link().Use();
// 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
(prog|"Position").Setup(n_per_vertex, DataType::Float).Enable();
}
// bind the VBO for the torus normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
(prog|"Normal").Setup(n_per_vertex, DataType::Float).Enable();
}
//
// set the light position
(prog/"LightPos").Set(Vec3f(4.0f, 4.0f, -8.0f));
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_torus.FaceWinding());
gl.CullFace(Face::Back);
glLineWidth(4.0f);
}
FlareExample(void)
: shape(shape_prog, shapes::SpiralSphere())
, n_flares(32)
, queries(n_flares)
{
std::vector<Vec3f> light_positions(n_flares);
for(GLuint i=0; i!=n_flares; ++i)
{
const float rand_max = float(RAND_MAX);
auto angle = FullCircles(std::rand()/rand_max);
light_positions[i] = Vec3f(
7.0f*Cos(angle),
0.2f*(std::rand()/rand_max)-0.1f,
7.0f*Sin(angle)
);
}
shape_prog.light_position.Set(light_positions);
shape_prog.color_1 = Vec3f(0.3f, 0.3f, 0.5f);
shape_prog.color_2 = Vec3f(0.8f, 0.8f, 1.0f);
Texture::Active(0);
shape_prog.metal_tex.Set(0);
metal_texture
<< TextureTarget::_2D
<< TextureMinFilter::LinearMipmapLinear
<< TextureMagFilter::Linear
<< TextureWrap::Repeat
<< images::BrushedMetalUByte(
512, 512,
5120,
-12, +12,
32, 64
)
<< TextureMipmap();
Texture::Active(1);
UniformSampler(flare_prog, "FlareTex").Set(1);
flare_texture
<< TextureTarget::_2D
<< TextureMinFilter::LinearMipmapLinear
<< TextureMagFilter::Linear
<< images::LoadTexture("flare_1")
<< TextureMipmap();
(TextureTarget::_2D|0) << TextureWrap::MirroredRepeat;
(TextureTarget::_2D|1) << TextureWrap::Repeat;
lights.Bind();
try
{
light_pos.Bind(Buffer::Target::Array);
Buffer::Data(Buffer::Target::Array, light_positions);
light_prog.Use();
VertexArrayAttrib light_attr(light_prog, "Position");
light_attr.Setup<Vec3f>();
light_attr.Enable();
flare_prog.Use();
VertexArrayAttrib flare_attr(flare_prog, "Position");
flare_attr.Setup<Vec3f>();
flare_attr.Enable();
}
catch(Error&)
{ }
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::ProgramPointSize);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::One);
}
