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