CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog)
, camera_matrix(prog)
{
// Set the vertex shader source and compile it
VertexShader vs;
vs.Source(
"#version 150\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"layout (std140) uniform ModelBlock {"
" mat4 ModelMatrices[36];"
"};"
"in vec4 Position;"
"out vec3 vertColor;"
"void main(void)"
"{"
" mat4 ModelMatrix = ModelMatrices[gl_InstanceID];"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
" vertColor = abs(normalize((ModelMatrix*Position).yxz));"
"}"
).Compile();
// set the fragment shader source and compile it
FragmentShader fs;
fs.Source(
"#version 150\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 1.0);"
"}"
).Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link().Use();
projection_matrix.BindTo("ProjectionMatrix");
camera_matrix.BindTo("CameraMatrix");
// bind the VAO for the cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
(prog|"Position").Setup<GLfloat>(n_per_vertex).Enable();
}
// make the matrices
{
// 36 x 4x4 matrices
std::vector<GLfloat> matrix_data(36*16);
auto p = matrix_data.begin(), e = matrix_data.end();
Angle<GLfloat> angle, astep = Angle<GLfloat>::Degrees(10);
while(p != e)
{
GLfloat cx = Cos(angle);
GLfloat sx = Sin(angle);
auto matrix = Transposed(Mat4f(
Vec4f( cx, 0.0, -sx, 0.0),
Vec4f(0.0, 1.0, 0.0, 0.0),
Vec4f( sx, 0.0, cx, 0.0),
Vec4f(0.0, 0.0, 0.0, 1.0)
) * Mat4f(
Vec4f(1.0, 0.0, 0.0,12.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)
));
p = std::copy(
Data(matrix),
Data(matrix)+Size(matrix),
p
);
angle += astep;
}
UniformBlock model_block(prog, "ModelBlock");
model_block.Binding(0);
block_buf.Bind(Buffer::Target::Uniform);
Buffer::Data(
Buffer::Target::Uniform,
matrix_data,
BufferUsage::DynamicDraw
);
block_buf.BindBaseUniform(0);
}
//
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.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 vec2 TexCoord;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" vertTexCoord = TexCoord;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float i = int(("
" vertTexCoord.x+"
" vertTexCoord.y "
" )*8) % 2;"
" fragColor = mix("
" vec4(0, 0, 0, 1),"
" vec4(1, 1, 0, 1),"
" 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 cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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).Enable();
}
// bind the VBO for the cube UV-coordinates
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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).Enable();
}
+Capability::DepthTest;
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
namespace se = oglplus::smart_enums;
VertexShader vs;
vs.Source(
"#version 120\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"attribute vec4 Position;"
"attribute vec3 Normal;"
"attribute vec2 TexCoord;"
"varying vec3 vertNormal;"
"varying vec3 vertLight;"
"varying vec2 vertTexCoord;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" gl_Position = ModelMatrix * Position;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
).Compile();
FragmentShader fs;
fs.Source(
"#version 120\n"
"uniform sampler2D TexUnit;"
"varying vec3 vertNormal;"
"varying vec3 vertLight;"
"varying vec2 vertTexCoord;"
"void main(void)"
"{"
" float l = length(vertLight);"
" float d = l > 0 ? dot(vertNormal, normalize(vertLight)) / l : 0.0;"
" float i = 0.3 + 2.0*max(d, 0.0);"
" vec4 t = texture2D(TexUnit, vertTexCoord);"
" gl_FragColor = vec4(t.rgb*i, 1.0);"
"}"
).Compile();
prog.AttachShader(vs).AttachShader(fs).Link().Use();
// bind the VAO for the cube
cube.Bind();
verts.Bind(se::Array());
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(se::Array(), data);
(prog|"Position").Setup(n_per_vertex, se::Float()).Enable();
}
normals.Bind(se::Array());
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(se::Array(), data);
(prog|"Normal").Setup(n_per_vertex, se::Float()).Enable();
}
texcoords.Bind(se::Array());
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(se::Array(), data);
(prog|"TexCoord").Setup(n_per_vertex, se::Float()).Enable();
}
// setup the texture
{
auto bound_tex = Bind(tex, se::_2D());
auto image = images::NewtonFractal(
512, 512,
Vec3f(1.0f, 1.4f, 1.3f),
Vec3f(0.2f, 0.3f, 0.1f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X4Minus1(),
[](double x) -> double
{
return pow(SineWave(pow(x,0.5)), 4.0);
}
);
bound_tex.Image2D(image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(se::LinearMipmapLinear());
bound_tex.MagFilter(se::Linear());
bound_tex.WrapS(se::Repeat());
bound_tex.WrapT(se::Repeat());
}
// set the uniform values
(prog/"TexUnit") = 0;
(prog/"LightPos") = Vec3f(1.0f, 2.0f, 3.0f);
//
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(se::DepthTest());
gl.Enable(se::CullFace());
gl.FrontFace(make_cube.FaceWinding());
}
FBTexExample(void)
: make_cube()
, cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, make_torus(1.0, 0.5, 72, 48)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, cube_fs(ObjectDesc("Cube fragment"))
, torus_fs(ObjectDesc("Torus fragment"))
, torus_projection_matrix(torus_prog, "ProjectionMatrix")
, torus_camera_matrix(torus_prog, "CameraMatrix")
, torus_model_matrix(torus_prog, "ModelMatrix")
, cube_projection_matrix(cube_prog, "ProjectionMatrix")
, cube_camera_matrix(cube_prog, "CameraMatrix")
, cube_model_matrix(cube_prog, "ModelMatrix")
, tex_side(512)
, width(tex_side)
, height(tex_side)
{
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)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" gl_Position = ModelMatrix * Position;"
" vertLight = LightPos-gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
vs.Compile();
cube_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.6 + max(d, 0.0);"
" fragColor = texture(TexUnit, vertTexCoord)*i;"
"}"
);
cube_fs.Compile();
cube_prog.AttachShader(vs);
cube_prog.AttachShader(cube_fs);
cube_prog.Link();
cube_prog.Use();
cube.Bind();
cube_verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(cube_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
cube_normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(cube_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
cube_texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(cube_prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
UniformSampler(cube_prog, "TexUnit").Set(0);
Uniform<Vec3f>(cube_prog, "LightPos").Set(4.0f, 4.0f, -8.0f);
torus_fs.Source(
"#version 330\n"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float d = dot("
" vertNormal, "
" normalize(vertLight)"
" );"
" float i = ("
" int(vertTexCoord.x*18) % 2+"
" int(vertTexCoord.y*14) % 2"
" ) % 2;"
" float c = (0.4 + max(d, 0.0))*(1-i/2);"
" fragColor = vec4(c, c, c, 1.0);"
"}"
);
torus_fs.Compile();
torus_prog.AttachShader(vs);
torus_prog.AttachShader(torus_fs);
torus_prog.Link();
torus_prog.Use();
torus.Bind();
torus_verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(torus_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
torus_normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(torus_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
torus_texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(torus_prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
Uniform<Vec3f>(torus_prog, "LightPos").Set(2.0f, 3.0f, 4.0f);
{
auto bound_tex = Bind(tex, Texture::Target::_2D);
bound_tex.Image2D(
0,
PixelDataInternalFormat::RGBA,
tex_side, tex_side,
0,
PixelDataFormat::RGBA,
PixelDataType::UnsignedByte,
nullptr
);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::Repeat);
bound_tex.WrapT(TextureWrap::Repeat);
}
{
auto bound_fbo = Bind(
fbo,
Framebuffer::Target::Draw
);
auto bound_rbo = Bind(
rbo,
Renderbuffer::Target::Renderbuffer
);
bound_rbo.Storage(
PixelDataInternalFormat::DepthComponent,
tex_side,
tex_side
);
bound_fbo.AttachTexture(
FramebufferAttachment::Color,
tex,
0
);
bound_fbo.AttachRenderbuffer(
FramebufferAttachment::Depth,
rbo
);
}
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.CullFace(Face::Back);
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
namespace se = oglplus::smart_enums;
// Set the vertex shader source
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)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" gl_Position = ModelMatrix * Position;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
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 = length(vertLight);"
" float d = l > 0 ? dot(vertNormal, normalize(vertLight)) / l : 0.0;"
" float i = 0.3 + 2.0*max(d, 0.0);"
" vec4 t = texture(TexUnit, vertTexCoord);"
" 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 cube
cube.Bind();
verts.Bind(se::Array());
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(se::Array(), data);
(prog|"Position").Setup(n_per_vertex, se::Float()).Enable();
}
normals.Bind(se::Array());
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(se::Array(), data);
(prog|"Normal").Setup(n_per_vertex, se::Float()).Enable();
}
texcoords.Bind(se::Array());
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(se::Array(), data);
(prog|"TexCoord").Setup(n_per_vertex, se::Float()).Enable();
}
// setup the texture
{
auto bound_tex = Bind(tex, se::_2D());
bound_tex.Image2D(images::LoadTexture("concrete_block"));
bound_tex.MinFilter(se::Linear());
bound_tex.MagFilter(se::Linear());
bound_tex.WrapS(se::Repeat());
bound_tex.WrapT(se::Repeat());
}
// set the uniform values
(prog/"TexUnit") = 0;
(prog/"LightPos") = Vec3f(1.0f, 2.0f, 3.0f);
//
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(se::DepthTest());
gl.Enable(se::CullFace());
gl.FrontFace(make_cube.FaceWinding());
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"in vec4 Position;"
"out vec3 vertColor;"
"void main(void)"
"{"
" float angle = gl_InstanceID * 10 * 2 * 3.14159 / 360.0;"
" float cx = cos(angle);"
" float sx = sin(angle);"
" mat4 ModelMatrix = mat4("
" cx, 0.0, sx, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" -sx, 0.0, cx, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ) * mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" 0.0, 0.0, 1.0, 0.0,"
" 12.0, 0.0, 0.0, 1.0 "
" );"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
" vertColor = abs(normalize((ModelMatrix*Position).xyz));"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 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 cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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);
attr.Enable();
}
//
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
void Render(double time)
{
// render into the texture
fbo.Bind(Framebuffer::Target::Draw);
gl.Viewport(tex_side, tex_side);
gl.ClearDepth(1.0f);
gl.ClearColor(0.4f, 0.9f, 0.4f, 1.0f);
gl.Clear().ColorBuffer().DepthBuffer();
torus_prog.Use();
torus_projection_matrix.Set(
CamMatrixf::PerspectiveX(Degrees(60), 1.0, 1, 30)
);
torus_camera_matrix.Set(
CamMatrixf::Orbiting(
Vec3f(),
3.5,
Degrees(time * 25),
Degrees(SineWave(time / 30.0) * 90)
)
);
torus_model_matrix.Set(
ModelMatrixf::RotationA(
Vec3f(1.0f, 1.0f, 1.0f),
FullCircles(time * 0.5)
)
);
torus.Bind();
gl.FrontFace(make_torus.FaceWinding());
torus_instr.Draw(torus_indices);
// render the textured cube
Framebuffer::BindDefault(Framebuffer::Target::Draw);
gl.Viewport(width, height);
gl.ClearDepth(1.0f);
gl.ClearColor(0.8f, 0.8f, 0.8f, 0.0f);
gl.Clear().ColorBuffer().DepthBuffer();
cube_prog.Use();
cube_projection_matrix.Set(
CamMatrixf::PerspectiveX(
Degrees(70),
double(width)/height,
1, 30
)
);
cube_camera_matrix.Set(
CamMatrixf::Orbiting(
Vec3f(),
3.0,
Degrees(time * 35),
Degrees(SineWave(time / 20.0) * 60)
)
);
cube_model_matrix.Set(
ModelMatrixf::RotationX(FullCircles(time * 0.25))
);
cube.Bind();
gl.FrontFace(make_cube.FaceWinding());
cube_instr.Draw(cube_indices);
}
PickingExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, vs(ShaderType::Vertex, ObjectDesc("Vertex"))
, gs(ShaderType::Geometry, ObjectDesc("Geometry"))
, fs(ShaderType::Fragment, ObjectDesc("Fragment"))
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"in vec4 Position;"
"out vec3 vertColor;"
"flat out int vertInstanceID;"
"void main(void)"
"{"
" float x = gl_InstanceID % 6 - 2.5;"
" float y = gl_InstanceID / 6 - 2.5;"
" mat4 ModelMatrix = mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" 0.0, 0.0, 1.0, 0.0,"
" 2*x, 2*y, 0.0, 1.0 "
" );"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
" vertColor = vec3("
" abs(normalize((ModelMatrix*Position).xy)),"
" 0.1"
" );"
" vertInstanceID = gl_InstanceID;"
"}"
);
vs.Compile();
// Set the geometry shader source
gs.Source(
"#version 330\n"
"layout(triangles) in;"
"layout(points, max_vertices = 1) out;"
"flat in int vertInstanceID[];"
"uniform vec2 MousePos;"
"out int geomInstanceID;"
"out float geomDepth;"
"vec2 barycentric_coords(vec4 a, vec4 b, vec4 c)"
"{"
// we'll need normalized device coordinates
// of the triangle vertices
" vec2 ad = vec2(a.x/a.w, a.y/a.w);"
" vec2 bd = vec2(b.x/b.w, b.y/b.w);"
" vec2 cd = vec2(c.x/c.w, c.y/c.w);"
" vec2 u = cd - ad;"
" vec2 v = bd - ad;"
" vec2 r = MousePos - ad;"
" float d00 = dot(u, u);"
" float d01 = dot(u, v);"
" float d02 = dot(u, r);"
" float d11 = dot(v, v);"
" float d12 = dot(v, r);"
" float id = 1.0 / (d00 * d11 - d01 * d01);"
" float ut = (d11 * d02 - d01 * d12) * id;"
" float vt = (d00 * d12 - d01 * d02) * id;"
" return vec2(ut, vt);"
"}"
"vec3 intersection(vec3 a, vec3 b, vec3 c, vec2 bc)"
"{"
" return (c - a)*bc.x + (b - a)*bc.y;"
"}"
"bool inside_triangle(vec2 b)"
"{"
" return ("
" (b.x >= 0.0) &&"
" (b.y >= 0.0) &&"
" (b.x + b.y <= 1.0)"
" );"
"}"
"void main(void)"
"{"
" vec2 bc = barycentric_coords("
" gl_in[0].gl_Position,"
" gl_in[1].gl_Position,"
" gl_in[2].gl_Position "
" );"
" if(inside_triangle(bc))"
" {"
" gl_Position = vec4(intersection("
" gl_in[0].gl_Position.xyz,"
" gl_in[1].gl_Position.xyz,"
" gl_in[2].gl_Position.xyz,"
" bc"
" ), 1.0);"
" geomDepth = gl_Position.z;"
" geomInstanceID = vertInstanceID[0];"
" EmitVertex();"
" EndPrimitive();"
" }"
"}"
);
gs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"flat in int vertInstanceID;"
"in vec3 vertColor;"
"uniform int Picked;"
"out vec4 fragColor;"
"void main(void)"
"{"
" if(vertInstanceID == Picked)"
" fragColor = vec4(1.0, 1.0, 1.0, 1.0);"
" else fragColor = vec4(vertColor, 1.0);"
"}"
);
fs.Compile();
// attach the shaders to the picking program
pick_prog.AttachShader(vs);
pick_prog.AttachShader(gs);
const GLchar* var_names[2] = {"geomDepth", "geomInstanceID"};
pick_prog.TransformFeedbackVaryings(
2, var_names,
TransformFeedbackMode::InterleavedAttribs
);
pick_prog.Link();
// attach the shaders to the drawing program
draw_prog.AttachShader(vs);
draw_prog.AttachShader(fs);
draw_prog.Link();
// bind the VAO for the cube
cube.Bind();
// buffer for the picked instance depths and IDs
picked_instances.Bind(Buffer::Target::TransformFeedback);
picked_instances.BindBase(
Buffer::IndexedTarget::TransformFeedback,
0
);
{
std::vector<DepthAndID> data(36, DepthAndID(0.0, 0));
Buffer::Data(Buffer::Target::TransformFeedback, data);
}
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
// make and upload the vertex data
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray draw_attr(draw_prog, "Position");
draw_attr.Setup<GLfloat>(n_per_vertex);
draw_attr.Enable();
}
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.FrontFace(make_cube.FaceWinding());
gl.CullFace(Face::Back);
gl.Enable(Capability::CullFace);
}
DOFExample(const ExampleParams& params)
: face_instr(make_cube.Instructions())
, edge_instr(make_cube.EdgeInstructions())
, face_indices(make_cube.Indices())
, edge_indices(make_cube.EdgeIndices())
, cube_matrices(MakeCubeMatrices(100, 10.0))
, viewport_width(dof_prog, "ViewportWidth")
, viewport_height(dof_prog, "ViewportHeight")
, projection_matrix(main_prog, "ProjectionMatrix")
, camera_matrix(main_prog, "CameraMatrix")
, model_matrix(main_prog, "ModelMatrix")
, ambient_color(main_prog, "AmbientColor")
, diffuse_color(main_prog, "DiffuseColor")
, focus_depth(dof_prog, "FocusDepth")
, color_tex(Texture::Target::Rectangle)
, depth_tex(Texture::Target::Rectangle)
, width(800)
, height(600)
{
main_vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"uniform vec3 LightPos;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertLightDir;"
"out vec3 vertNormal;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertLightDir = normalize(LightPos - gl_Position.xyz);"
" vertNormal = normalize(mat3(ModelMatrix)*Normal);"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
main_vs.Compile();
// set the fragment shader source
main_fs.Source(
"#version 330\n"
"uniform vec3 AmbientColor, DiffuseColor;"
"in vec3 vertLightDir;"
"in vec3 vertNormal;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float d = max(dot(vertLightDir,vertNormal),0.0);"
" float e = sin("
" 10.0*vertLightDir.x + "
" 20.0*vertLightDir.y + "
" 25.0*vertLightDir.z "
" )*0.9;"
" fragColor = vec4("
" mix(AmbientColor, DiffuseColor, d+e),"
" 1.0"
" );"
"}"
);
// compile it
main_fs.Compile();
// attach the shaders to the program
main_prog.AttachShader(main_vs);
main_prog.AttachShader(main_fs);
// link and use it
main_prog.Link();
main_prog.Use();
// bind the VAO for the cube
cube.Bind();
// bind the VBO for the cube vertices
positions.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the vertices
VertexAttribArray attr(main_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the cube normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(main_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
Uniform<Vec3f>(main_prog, "LightPos").Set(30.0, 50.0, 20.0);
dof_vs.Source(
"#version 330\n"
"uniform uint ViewportWidth, ViewportHeight;"
"in vec4 Position;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Position;"
" vertTexCoord = vec2("
" (Position.x*0.5 + 0.5)*ViewportWidth,"
" (Position.y*0.5 + 0.5)*ViewportHeight"
" );"
"}"
);
dof_vs.Compile();
dof_fs.Source(
"#version 330\n"
"uniform sampler2DRect ColorTex;"
"uniform sampler2DRect DepthTex;"
"uniform float FocusDepth;"
"uniform uint SampleMult;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"const float strength = 16.0;"
"void main(void)"
"{"
" float fragDepth = texture(DepthTex, vertTexCoord).r;"
" vec3 color = texture(ColorTex, vertTexCoord).rgb;"
" float of = abs(fragDepth - FocusDepth);"
" int nsam = int(of*SampleMult);"
" float inv_nsam = 1.0 / (1.0 + nsam);"
" float astep = (3.14151*4.0)/nsam;"
" for(int i=0; i!=nsam; ++i)"
" {"
" float a = i*astep;"
" float d = sqrt(i*inv_nsam);"
" float sx = cos(a)*of*strength*d;"
" float sy = sin(a)*of*strength*d;"
" vec2 samTexCoord = vertTexCoord + vec2(sx, sy) + noise2(vec2(sx, sy));"
" color += texture(ColorTex, samTexCoord).rgb;"
" }"
" fragColor = vec4(color * inv_nsam , 1.0);"
"}"
);
dof_fs.Compile();
dof_prog.AttachShader(dof_vs);
dof_prog.AttachShader(dof_fs);
dof_prog.Link();
dof_prog.Use();
GLuint sample_mult = params.HighQuality()?512:128;
Uniform<GLuint>(dof_prog, "SampleMult") = sample_mult;
// bind the VAO for the screen
screen.Bind();
corners.Bind(Buffer::Target::Array);
{
GLfloat screen_verts[8] = {
-1.0f, -1.0f,
-1.0f, 1.0f,
1.0f, -1.0f,
1.0f, 1.0f
};
Buffer::Data(Buffer::Target::Array, 8, screen_verts);
VertexAttribArray attr(dof_prog, "Position");
attr.Setup<Vec2f>();
attr.Enable();
}
Texture::Active(0);
UniformSampler(dof_prog, "ColorTex").Set(0);
{
auto bound_tex = Bind(color_tex, Texture::Target::Rectangle);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.Image2D(
0,
PixelDataInternalFormat::RGB,
width, height,
0,
PixelDataFormat::RGB,
PixelDataType::UnsignedByte,
nullptr
);
}
Texture::Active(1);
UniformSampler(dof_prog, "DepthTex").Set(1);
{
auto bound_tex = Bind(depth_tex, Texture::Target::Rectangle);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.Image2D(
0,
PixelDataInternalFormat::DepthComponent,
width, height,
0,
PixelDataFormat::DepthComponent,
PixelDataType::Float,
nullptr
);
}
{
auto bound_fbo = Bind(
fbo,
Framebuffer::Target::Draw
);
bound_fbo.AttachTexture(
FramebufferAttachment::Color,
color_tex,
0
);
bound_fbo.AttachTexture(
FramebufferAttachment::Depth,
depth_tex,
0
);
}
//
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.DepthFunc(CompareFn::LEqual);
gl.Enable(Capability::LineSmooth);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::OneMinusSrcAlpha);
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, prog(make_prog())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
, light_pos(prog, "LightPos")
{
gl.Bind(cube);
gl.Bind(Buffer::Target::Array, verts);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
gl.Current(Buffer::Target::Array).Data(data);
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, normals);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
gl.Current(Buffer::Target::Array).Data(data);
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, tangents);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Tangents(data);
gl.Current(Buffer::Target::Array).Data(data);
VertexArrayAttrib attr(prog, "Tangent");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, texcoords);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
gl.Current(Buffer::Target::Array).Data(data);
VertexArrayAttrib attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the textures
{
Texture::Active(0);
UniformSampler(prog, "ColorTex").Set(0);
gl.Bind(Texture::Target::_2D, colorTex);
gl.Current(Texture::Target::_2D)
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat)
.Image2D(images::LoadTexture("wooden_crate"))
.GenerateMipmap();
}
{
Texture::Active(1);
UniformSampler(prog, "NormalTex").Set(1);
gl.Bind(Texture::Target::_2D, normalTex);
gl.Current(Texture::Target::_2D)
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat)
.Image2D(
images::NormalMap(
images::LoadTexture("wooden_crate-hmap")
)
).GenerateMipmap();
}
//
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_cube.FaceWinding());
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
, light_pos(prog, "LightPos")
{
namespace se = oglplus::smart_enums;
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec3 Tangent;"
"in vec2 TexCoord;"
"out vec3 vertLight;"
"out vec2 vertTexCoord;"
"out mat3 NormalMatrix;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vec3 fragNormal = mat3(ModelMatrix) * Normal;"
" vec3 fragTangent = mat3(ModelMatrix) * Tangent;"
" NormalMatrix[0] = fragTangent;"
" NormalMatrix[1] = cross(fragNormal, fragTangent);"
" NormalMatrix[2] = fragNormal;"
" gl_Position = ModelMatrix * Position;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform sampler2D ColorTex, NormalTex;"
"in mat3 NormalMatrix;"
"in vec3 vertLight;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = dot(vertLight, vertLight);"
" vec3 n = texture(NormalTex, vertTexCoord).xyz;"
" vec3 finalNormal = NormalMatrix * n;"
" float d = (l > 0.0) ? dot("
" normalize(vertLight), "
" finalNormal"
" ) / l : 0.0;"
" float i = 0.2 + 4.5*max(d, 0.0);"
" vec4 t = texture(ColorTex, vertTexCoord);"
" 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 cube
cube.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(se::Array(), data);
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(se::Array(), data);
VertexAttribArray attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
tangents.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Tangents(data);
Buffer::Data(se::Array(), data);
VertexAttribArray attr(prog, "Tangent");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(se::Array(), data);
VertexAttribArray attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the textures
{
Texture::Active(0);
UniformSampler(prog, "ColorTex").Set(0);
auto bound_tex = Bind(colorTex, se::_2D());
bound_tex.Image2D(images::LoadTexture("wooden_crate"));
bound_tex.GenerateMipmap();
bound_tex.MinFilter(se::LinearMipmapLinear());
bound_tex.MagFilter(se::Linear());
bound_tex.WrapS(se::Repeat());
bound_tex.WrapT(se::Repeat());
}
{
Texture::Active(1);
UniformSampler(prog, "NormalTex").Set(1);
auto bound_tex = Bind(normalTex, se::_2D());
bound_tex.Image2D(
images::NormalMap(
images::LoadTexture("wooden_crate-hmap"),
images::NormalMap::FromRed()
)
);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(se::LinearMipmapLinear());
bound_tex.MagFilter(se::Linear());
bound_tex.WrapS(se::Repeat());
bound_tex.WrapT(se::Repeat());
}
//
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(se::DepthTest());
gl.Enable(se::CullFace());
gl.FrontFace(make_cube.FaceWinding());
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
{
// Set the vertex shader source and compile it
vs.Source(
"#version 330\n"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = Position;"
"}"
).Compile();
// Set the geometry shader source and compile it
gs.Source(
"#version 330\n"
"layout(triangles) in;"
"layout(triangle_strip, max_vertices = 108) out;"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"out vec3 vertColor;"
"void main(void)"
"{"
" for(int c=0; c!=36; ++c)"
" {"
" float angle = c * 10 * 2 * 3.14159 / 360.0;"
" float cx = cos(angle);"
" float sx = sin(angle);"
" mat4 ModelMatrix = mat4("
" cx, 0.0, sx, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" -sx, 0.0, cx, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ) * mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" 0.0, 0.0, 1.0, 0.0,"
" 12.0, 0.0, 0.0, 1.0 "
" );"
" for(int v=0; v!=gl_in.length(); ++v)"
" {"
" vec4 vert = gl_in[v].gl_Position;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" vert;"
" vertColor = abs(normalize(ModelMatrix*vert)).xzy;"
" EmitVertex();"
" }"
" EndPrimitive();"
" }"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"in vec3 vertColor;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(vertColor, 1.0);"
"}"
).Compile();
// attach the shaders to the program
prog << vs << gs << fs;
// link and use it
prog.Link().Use();
// bind the VAO for the cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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();
}
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, light_pos(prog, "LightPos")
, projection_matrix(prog, "ProjectionMatrix")
, tex_projection_matrix(prog, "TexProjectionMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"uniform mat4 TexProjectionMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"out vec4 vertTexCoord;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vertNormal = ("
" ModelMatrix *"
" vec4(-Normal, 0.0)"
" ).xyz;"
" vertLight = ("
" vec4(LightPos, 0.0)-"
" ModelMatrix * Position"
" ).xyz;"
" vertTexCoord = "
" TexProjectionMatrix *"
" ModelMatrix *"
" Position;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ModelMatrix *"
" Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform sampler2D TexUnit;"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"in vec4 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = length(vertLight);"
" float d = l != 0.0 ? dot("
" vertNormal, "
" normalize(vertLight)"
" ) / l : 0.0;"
" float i = 0.1 + 4.2*max(d, 0.0);"
" vec2 coord = vertTexCoord.st/vertTexCoord.q;"
" vec4 t = texture(TexUnit, coord*0.5 + 0.5);"
" fragColor = vec4(t.rgb*i*sqrt(1.0-t.a), 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 cube
cube.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
gl.Direct(Texture::Target::_2D, tex)
.Image2D(images::LoadTexture("flower_glass"))
.GenerateMipmap()
.BorderColor(Vec4f(1.0f, 1.0f, 1.0f, 0.0f))
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::ClampToBorder)
.WrapT(TextureWrap::ClampToBorder)
.Bind();
UniformSampler(prog, "TexUnit").Set(0);
Uniform<Mat4f>(prog, "CameraMatrix").Set(
CamMatrixf::LookingAt(Vec3f(0.0f, 1.0f, 2.0f), Vec3f())
);
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_cube.FaceWinding());
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source
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)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" gl_Position = ModelMatrix * Position;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord * 6.0;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
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 = dot(vertLight, vertLight);"
" float d = l != 0.0 ? dot("
" vertNormal, "
" normalize(vertLight)"
" ) / l : 0.0;"
" vec3 c = vec3(0.9, 0.8, 0.2);"
" vec4 t = texture(TexUnit, vertTexCoord);"
" float a = 1.0 - sqrt(abs(d)), e;"
" if(gl_FrontFacing)"
" {"
" e = d >= 0.0 ?"
" d * mix(0.5, 1.0, t.a):"
" (-0.9*d) * (1.0 - t.a);"
" }"
" else"
" {"
" e = d >= 0.0 ?"
" (0.6*d) * (1.0 - t.a):"
" (-0.7*d) * mix(0.5, 1.0, t.a);"
" }"
" float i = 0.1 + 9.0*e;"
" fragColor = vec4("
" t.r*c.r*i, "
" t.g*c.g*i, "
" t.b*c.b*i, "
" clamp(pow(t.a,2) + a*0.4, 0.0, 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 cube
cube.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Normal");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "TexCoord");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
// setup the texture
{
auto bound_tex = Bind(tex, Texture::Target::_2D);
bound_tex.Image2D(images::LoadTexture("honeycomb"));
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::MirroredRepeat);
bound_tex.WrapT(TextureWrap::MirroredRepeat);
}
//
UniformSampler(prog, "TexUnit").Set(0);
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(1.0f, 2.0f, 3.0f));
//
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::Blend);
gl.BlendFunc(
BlendFn::SrcAlpha,
BlendFn::OneMinusSrcAlpha
);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_cube.FaceWinding());
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
, front_facing(prog, "FrontFacing")
, inst_count(32)
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"uniform vec3 LightPos;"
"uniform int InstCount;"
"uniform int FrontFacing;"
"in vec4 Position;"
"in vec3 Normal;"
"out float vertMult;"
"out vec3 vertColor;"
"out vec3 vertWrapNormal;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"void main(void)"
"{"
" int inst = (FrontFacing != 0) ? "
" (InstCount - gl_InstanceID - 1):"
" gl_InstanceID;"
" vertMult = float(inst) / float(InstCount-1);"
" float sca = 1.0 - 0.3 * pow(vertMult, 2);"
" mat4 ScaleMatrix = mat4("
" sca, 0.0, 0.0, 0.0,"
" 0.0, sca, 0.0, 0.0,"
" 0.0, 0.0, sca, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" );"
" gl_Position = ModelMatrix * Position;"
" vertColor = Normal;"
" vec3 wrap = Position.xyz - Normal;"
" vertWrapNormal = "
" mat3(ModelMatrix)*"
" normalize(mix("
" Normal,"
" wrap,"
" mix(0.5, 1.0, vertMult)"
" ));"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos-gl_Position.xyz;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" ScaleMatrix *"
" gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"in float vertMult;"
"in vec3 vertColor;"
"in vec3 vertWrapNormal;"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"out vec4 fragColor;"
"uniform int InstCount;"
"void main(void)"
"{"
" float l = dot(vertLight, vertLight);"
" float d = l > 0.0 ? dot("
" vertNormal, "
" normalize(vertLight)"
" ) / l : 0.0;"
" float s = max("
" dot(vertWrapNormal, vertLight)/l,"
" 0.0"
" );"
" float intensity = clamp("
" 0.2 + d * 3.0 + s * 5.5,"
" 0.0,"
" 1.0"
" );"
" fragColor = vec4("
" abs(vertColor) * intensity,"
" (2.5 + 1.5*d + 1.5*s) / InstCount"
" );"
"}"
);
// 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 cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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 cube normals
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// the light position
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(-3.0f, -2.0f, -3.0f));
// and the instance count
Uniform<GLint>(prog, "InstCount").Set(inst_count);
//
gl.ClearColor(0.5f, 0.6f, 0.5f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_cube.FaceWinding());
gl.Enable(Capability::Blend);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::OneMinusSrcAlpha);
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, prog(make_prog())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// bind the VAO for the cube
gl.Bind(cube);
gl.Bind(Buffer::Target::Array, verts);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, normals);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, texcoords);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
gl.Bound(Texture::Target::_2D, tex)
.Image2D(images::LoadTexture("honeycomb"))
.GenerateMipmap()
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::MirroredRepeat)
.WrapT(TextureWrap::MirroredRepeat)
.Anisotropy(2);
//
UniformSampler(prog, "TexUnit").Set(0);
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(1.0f, 2.0f, 3.0f));
//
gl.ClearColor(0.1f, 0.1f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::Blend);
gl.BlendFunc(
BlendFn::SrcAlpha,
BlendFn::OneMinusSrcAlpha
);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_cube.FaceWinding());
}
CubeExample(void)
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" vertTexCoord = TexCoord;"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float i = ("
" 1 +"
" int(vertTexCoord.x*8) % 2+"
" int(vertTexCoord.y*8) % 2"
" ) % 2;"
" fragColor = vec4(i, i, 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 cube
cube.Bind();
// bind the VBO for the cube vertices
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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);
attr.Enable();
}
// bind the VBO for the cube texture-coordinates
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.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(n_per_vertex, DataType::Float);
attr.Enable();
}
//
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
CubeExample()
: cube_instr(make_cube.Instructions())
, cube_indices(make_cube.Indices())
, prog(make())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
, light_pos(prog, "LightPos") {
// bind the VAO for the cube
gl.Bind(cube);
gl.Bind(Buffer::Target::Array, verts);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
(prog | "Position").Setup<GLfloat>(n_per_vertex).Enable();
}
gl.Bind(Buffer::Target::Array, normals);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
(prog | "Normal").Setup<GLfloat>(n_per_vertex).Enable();
}
gl.Bind(Buffer::Target::Array, tangents);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Tangents(data);
Buffer::Data(Buffer::Target::Array, data);
(prog | "Tangent").Setup<GLfloat>(n_per_vertex).Enable();
}
gl.Bind(Buffer::Target::Array, texcoords);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
(prog | "TexCoord").Setup<GLfloat>(n_per_vertex).Enable();
}
{
auto img = images::SphereBumpMap(512, 512, 2, 2);
Uniform<GLsizei>(prog, "BumpTexWidth").Set(img.Width());
Uniform<GLsizei>(prog, "BumpTexHeight").Set(img.Height());
UniformSampler(prog, "BumpTex").Set(0);
Texture::Active(0);
gl.Bound(Texture::Target::_2D, bumpTex)
.MinFilter(TextureMinFilter::LinearMipmapLinear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat)
.Image2D(img)
.GenerateMipmap();
}
//
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_cube.FaceWinding());
}