LiquidExample(const ExampleParams& params)
: liquid_prog()
, grid(liquid_prog, params.quality)
, grid_repeat(int(1 + params.quality*2))
{
Texture::Active(1);
{
auto image = images::Squares(512, 512, 0.9f, 8, 8);
auto bound_tex = gl.Bound(Texture::Target::CubeMap, env_map);
for(int i=0; i!=6; ++i)
Texture::ImageCM(i, image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
bound_tex.SwizzleG(TextureSwizzle::Red);
bound_tex.SwizzleB(TextureSwizzle::Red);
}
ProgramUniformSampler(liquid_prog, "EnvMap").Set(1);
const Vec3f light_position(12.0, 1.0, 8.0);
liquid_prog.light_position.Set(light_position);
gl.ClearColor(0.7f, 0.65f, 0.55f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CW);
gl.CullFace(Face::Back);
}
LiquidExample(const ExampleParams& params)
: liquid_prog()
, grid(liquid_prog, params.quality)
, grid_repeat(1 + params.quality*2)
{
Texture::Active(0);
{
auto image = images::NewtonFractal(
256, 256,
Vec3f(0.1f, 0.1f, 0.1f),
Vec3f(1.0f, 1.0f, 1.0f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X4Minus1(),
images::NewtonFractal::DefaultMixer()
);
auto bound_tex = oglplus::Context::Bound(
Texture::Target::CubeMap,
env_map
);
for(int i=0; i!=6; ++i)
Texture::ImageCM(i, image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
}
ProgramUniformSampler(liquid_prog, "EnvMap").Set(0);
const Vec3f light_position(12.0, 1.0, 8.0);
liquid_prog.light_position.Set(light_position);
gl.ClearColor(0.7f, 0.65f, 0.55f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(FaceOrientation::CW);
gl.CullFace(Face::Back);
}
EnvMap(GLuint tex_unit)
: _tex_unit(tex_unit)
{
Texture::Active(_tex_unit);
auto bound_tex = oglplus::Bind(*this, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
Texture::Image2D(
Texture::CubeMapFace(0),
images::LoadTexture("cloudy_day-cm_0", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(1),
images::LoadTexture("cloudy_day-cm_1", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(2),
images::LoadTexture("cloudy_day-cm_2", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(3),
images::LoadTexture("cloudy_day-cm_3", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(4),
images::LoadTexture("cloudy_day-cm_4", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(5),
images::LoadTexture("cloudy_day-cm_5", false, false)
);
}
CubeMapExample(void)
: make_shape(4)
, shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"out vec3 vertNormal;"
"out vec3 vertTexCoord;"
"out vec3 vertLightDir;"
"out vec3 vertViewDir;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vec3 Normal = Position.xyz;"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertTexCoord = Normal;"
" vertLightDir = LightPos - gl_Position.xyz;"
" vertViewDir = (vec4(0.0, 0.0, 1.0, 1.0)*CameraMatrix).xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
vs.Compile();
gs.Source(
"#version 330\n"
"layout (triangles) in;"
"layout (triangle_strip, max_vertices = 3) out;"
"in vec3 vertNormal[3];"
"in vec3 vertTexCoord[3];"
"in vec3 vertLightDir[3];"
"in vec3 vertViewDir[3];"
"out vec3 geomNormal;"
"out vec3 geomTexCoord;"
"out vec3 geomLightDir;"
"out vec3 geomLightRefl;"
"out vec3 geomViewDir;"
"void main(void)"
"{"
" vec3 FaceNormal = 0.333333*("
" vertNormal[0]+"
" vertNormal[1]+"
" vertNormal[2] "
" );"
" for(int v=0; v!=3; ++v)"
" {"
" gl_Position = gl_in[v].gl_Position;"
" geomNormal = 0.5*(vertNormal[v]+FaceNormal);"
" geomTexCoord = vertTexCoord[v];"
" geomLightDir = vertLightDir[v];"
" geomLightRefl = reflect("
" -normalize(geomLightDir),"
" normalize(FaceNormal)"
" );"
" geomViewDir = vertViewDir[v];"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
);
gs.Compile();
fs.Source(
"#version 330\n"
"uniform samplerCube TexUnit;"
"in vec3 geomNormal;"
"in vec3 geomTexCoord;"
"in vec3 geomLightDir;"
"in vec3 geomLightRefl;"
"in vec3 geomViewDir;"
"out vec3 fragColor;"
"void main(void)"
"{"
" vec3 lt = vec3(1.0, 1.0, 1.0);"
" vec3 tex = texture(TexUnit, geomTexCoord).rgb;"
" float d = dot("
" normalize(geomNormal), "
" normalize(geomLightDir)"
" );"
" float s = dot("
" normalize(geomLightRefl),"
" normalize(geomViewDir)"
" );"
" float b = 1.0-sqrt(max(dot("
" normalize(geomNormal),"
" normalize(geomViewDir)"
" ), 0.0));"
" float ea = clamp(tex.b*(-d+0.2), 0.0, 1.0);"
" float sr = 1.0-tex.b*0.8;"
" fragColor = "
" tex * (0.3*ea + 0.6*b + 0.8*max(d, 0.0)) + "
" (tex+lt) * 0.8*sr*pow(clamp(s+0.05, 0.0, 1.0), 32);"
"}"
);
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(gs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the shape
shape.Bind();
positions.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
{
auto bound_tex = Bind(tex, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
const char* tex_name[6] = {
"cube_0_right",
"cube_1_left",
"cube_2_top",
"cube_3_bottom",
"cube_4_front",
"cube_5_back"
};
for(GLuint i=0; i!=6; ++i)
{
Texture::Image2D(
Texture::CubeMapFace(i),
images::LoadTexture(tex_name[i], false, true)
);
}
}
UniformSampler(prog, "TexUnit").Set(0);
//
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(3.0f, 5.0f, 4.0f));
//
gl.ClearColor(0.05f, 0.2f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
gl.CullFace(Face::Back);
}
CloudExample(void)
: projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
{
// Set the vertex shader source
vs.Source(
"#version 330\n"
"in vec4 Position;"
"uniform mat4 CameraMatrix;"
"void main(void)"
"{"
" gl_Position = "
" CameraMatrix *"
" Position;"
"}"
);
// compile it
vs.Compile();
// Set the geometry shader source
gs.Source(
"#version 330\n"
"layout(points) in;"
"layout(triangle_strip, max_vertices = 100) out;"
"const int p = 25;"
"const float hp = (p-1)*0.5;"
"uniform vec3 LightPos;"
"uniform mat4 CameraMatrix, ProjectionMatrix;"
"out vec3 geomTexCoord;"
"out vec3 geomLightDir;"
"void main(void)"
"{"
" float s = 0.6;"
" float yo[2] = float[2](-1.0, 1.0);"
" float xo[2] = float[2](-1.0, 1.0);"
" vec3 cx = vec3("
" CameraMatrix[0][0],"
" CameraMatrix[1][0],"
" CameraMatrix[2][0] "
" );"
" vec3 cy = vec3("
" CameraMatrix[0][1],"
" CameraMatrix[1][1],"
" CameraMatrix[2][1] "
" );"
" vec3 cz = vec3("
" CameraMatrix[0][2],"
" CameraMatrix[1][2],"
" CameraMatrix[2][2] "
" );"
" for(int k=0;k!=p;++k)"
" {"
" for(int j=0;j!=2;++j)"
" for(int i=0;i!=2;++i)"
" {"
" float zo = ((k - hp) / hp);"
" float xoffs = xo[i]*s;"
" float yoffs = yo[j]*s;"
" float zoffs = zo *s;"
" vec4 v = vec4("
" gl_in[0].gl_Position.x+xoffs,"
" gl_in[0].gl_Position.y+yoffs,"
" gl_in[0].gl_Position.z+zoffs,"
" 1.0"
" );"
" gl_Position = ProjectionMatrix * v;"
" geomLightDir = LightPos - v.xyz;"
" geomTexCoord = "
" vec3(0.5, 0.5, 0.5)+"
" cx*(xo[i])*0.707+"
" cy*(yo[j])*0.707+"
" cz*(zo )*0.707;"
" EmitVertex();"
" }"
" EndPrimitive();"
" }"
"}"
);
// compile it
gs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform sampler3D cloudTex;"
"in vec3 geomTexCoord;"
"in vec3 geomLightDir;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float d = texture(cloudTex, geomTexCoord).r;"
" float o = 1.0;"
" float s = 2.0/128.0;"
" float r = s * 8.0;"
" vec3 sampleOffs = normalize(geomLightDir) * s;"
" vec3 samplePos = geomTexCoord;"
" if(d > 0.01) while(o > 0.0)"
" {"
" if(samplePos.x<0.0 || samplePos.x>1.0)"
" break;"
" if(samplePos.y<0.0 || samplePos.y>1.0)"
" break;"
" if(samplePos.z<0.0 || samplePos.z>1.0)"
" break;"
" o -= texture(cloudTex, samplePos).r*r;"
" samplePos += sampleOffs;"
" }"
" float a = 0.2 * d;"
" float i = mix(0.4, 1.0, o);"
" fragColor = vec4(i, i, i, a);"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(gs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the clouds
clouds.Bind();
// bind the VBO for the cloud positions
buffer.Bind(Buffer::Target::Array);
{
GLfloat positions[3] = {0.5f, 0.1f, 0.2f};
Buffer::Data(Buffer::Target::Array, 3, positions);
VertexAttribArray attr(prog, "Position");
attr.Setup(3, DataType::Float);
attr.Enable();
}
{
Texture::Active(0);
UniformSampler(prog, "cloudTex").Set(0);
auto bound_tex = Bind(cloud_tex, Texture::Target::_3D);
bound_tex.Image3D(images::Cloud(128, 128, 128));
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.BorderColor(Vec4f(0.0f, 0.0f, 0.0f, 0.0f));
bound_tex.WrapS(TextureWrap::ClampToBorder);
bound_tex.WrapT(TextureWrap::ClampToBorder);
bound_tex.WrapR(TextureWrap::ClampToBorder);
}
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(10.0f, 1.0f, 5.0f));
gl.ClearColor(0.2f, 0.3f, 0.4f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::Blend);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::OneMinusSrcAlpha);
}
SketchExample(void)
: transf_prog()
, sketch_prog()
, plane(
transf_prog,
shapes::Plane(
Vec3f(0, 0, 0),
Vec3f(9, 0, 0),
Vec3f(0, 0,-9),
9, 9
)
), torus(transf_prog, shapes::WickerTorus())
, sketch_tex_layers(8)
, shadow_tex_side(1024)
{
NoProgram().Use();
shadow_pp.Bind();
shadow_pp.UseStages(transf_prog).Vertex();
shadow_pp.UseStages(shadow_prog).Fragment();
sketch_pp.Bind();
sketch_pp.UseStages(transf_prog).Vertex();
sketch_pp.UseStages(sketch_prog).Fragment();
line_pp.Bind();
line_pp.UseStages(transf_prog).Vertex();
line_pp.UseStages(line_prog).Geometry().Fragment();
Texture::Active(0);
sketch_prog.sketch_tex.Set(0);
{
auto bound_tex = gl.Bound(Texture::Target::_3D, sketch_texture);
for(GLuint i=0; i<sketch_tex_layers; ++i)
{
auto image = images::BrushedMetalUByte(
512, 512,
64 + i*128,
-(2+i*4), +(2+i*4),
64, 256-i*4
);
if(i == 0)
{
bound_tex.Image3D(
0,
PixelDataInternalFormat::RGB,
image.Width(),
image.Height(),
sketch_tex_layers,
0,
image.Format(),
image.Type(),
nullptr
);
}
bound_tex.SubImage3D(
0,
0, 0, i,
image.Width(),
image.Height(),
1,
image.Format(),
image.Type(),
image.RawData()
);
}
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::Repeat);
bound_tex.WrapT(TextureWrap::Repeat);
bound_tex.WrapR(TextureWrap::ClampToEdge);
}
Texture::Active(1);
sketch_prog.shadow_tex.Set(1);
gl.Bound(Texture::Target::_2D, shadow_tex)
.MinFilter(TextureMinFilter::Linear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::ClampToEdge)
.WrapT(TextureWrap::ClampToEdge)
.CompareMode(TextureCompareMode::CompareRefToTexture)
.Image2D(
0,
PixelDataInternalFormat::DepthComponent32,
shadow_tex_side, shadow_tex_side,
0,
PixelDataFormat::DepthComponent,
PixelDataType::Float,
nullptr
);
gl.Bound(Framebuffer::Target::Draw, frame_shadow_fbo)
.AttachTexture(
FramebufferAttachment::Depth,
shadow_tex,
0
);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.DepthFunc(CompareFn::LEqual);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::OneMinusSrcAlpha);
gl.PolygonOffset(1.0, 1.0);
gl.LineWidth(1.5);
}
CubeMapExample(void)
: shape_instr(make_shape.Instructions())
, shape_indices(make_shape.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 vertLightDir;"
"out vec3 vertLightRefl;"
"out vec3 vertViewDir;"
"out vec3 vertViewRefl;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLightDir = LightPos - gl_Position.xyz;"
" vertLightRefl = reflect("
" -normalize(vertLightDir),"
" normalize(vertNormal)"
" );"
" vertViewDir = ("
" vec4(0.0, 0.0, 1.0, 1.0)*"
" CameraMatrix"
" ).xyz;"
" vertViewRefl = reflect("
" normalize(vertViewDir),"
" normalize(vertNormal)"
" );"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
// compile it
vs.Compile();
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform samplerCube TexUnit;"
"in vec3 vertNormal;"
"in vec3 vertLightDir;"
"in vec3 vertLightRefl;"
"in vec3 vertViewDir;"
"in vec3 vertViewRefl;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = length(vertLightDir);"
" float d = dot("
" normalize(vertNormal), "
" normalize(vertLightDir)"
" ) / l;"
" float s = dot("
" normalize(vertLightRefl),"
" normalize(vertViewDir)"
" );"
" vec3 lt = vec3(1.0, 1.0, 1.0);"
" vec3 env = texture(TexUnit, vertViewRefl).rgb;"
" fragColor = vec4("
" env * 0.4 + "
" (lt + env) * 1.5 * max(d, 0.0) + "
" lt * pow(max(s, 0.0), 64), "
" 1.0"
" );"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the shape
shape.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Normal");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
// setup the texture
{
GLuint tex_side = 256;
auto image = images::NewtonFractal(
tex_side, tex_side,
Vec3f(0.3f, 0.1f, 0.2f),
Vec3f(1.0f, 0.8f, 0.9f),
Vec2f(-1.0f, -1.0f),
Vec2f( 1.0f, 1.0f),
images::NewtonFractal::X4Minus1(),
images::NewtonFractal::DefaultMixer()
);
auto bound_tex = Bind(tex, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
for(int i=0; i!=6; ++i)
Texture::Image2D(Texture::CubeMapFace(i), image);
}
// typechecked uniform with the exact sampler type
// on compilers supporting strongly typed enums
// you can use:
//Typechecked<Uniform<SLtoCpp<SLDataType::SamplerCube>>>(prog, "TexUnit").Set(0);
// without strongly typed enums you need to do:
typedef SLtoCpp<OGLPLUS_CONST_ENUM_VALUE(SLDataType::SamplerCube)> GLSLsamplerCube;
Typechecked<Uniform<GLSLsamplerCube>>(prog, "TexUnit").Set(0);
//
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(3.0f, 5.0f, 4.0f));
//
gl.ClearColor(0.2f, 0.05f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
gl.CullFace(Face::Back);
}
CloudExample(const ExampleParams& params)
: sphere_instr(make_sphere.Instructions())
, sphere_indices(make_sphere.Indices())
, samples(25 + params.quality*params.quality*100)
, positions(make_positions())
, sizes(make_sizes())
, cloud_tex(positions.size())
, light_path(make_light_path_cps())
{
assert(positions.size() == sizes.size());
std::srand(123456);
light_vs.Source(
"#version 330\n"
"in vec3 Position;"
"uniform vec3 LightPos;"
"uniform mat4 CameraMatrix, ProjectionMatrix;"
"void main(void)"
"{"
" float s = 0.1;"
" gl_Position = "
" ProjectionMatrix*"
" CameraMatrix*"
" vec4(Position*s + LightPos, 1.0);"
"}"
).Compile();
light_fs.Source(
"#version 330\n"
"out vec4 fragLight;"
"void main(void)"
"{"
" fragLight = vec4(1.0, 1.0, 1.0, 1.0);"
"}"
).Compile();
light_prog << light_vs << light_fs;
light_prog.Link().Use();
light.Bind();
buffer.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_sphere.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
(light_prog|"Position").Setup(n_per_vertex, DataType::Float).Enable();
}
cloud_vs.Source(
"#version 330\n"
"in vec4 Position;"
"in float Size;"
"uniform int SampleCount;"
"uniform mat4 CameraMatrix;"
"uniform vec4 ViewZ;"
"out float vertZOffs;"
"out float vertSize;"
"void main(void)"
"{"
" float hp = (SampleCount-1) * 0.5;"
" vertZOffs = (gl_InstanceID - hp)/hp;"
" vertSize = Size;"
" gl_Position = vec4("
" Position.xyz +"
" ViewZ.xyz*vertZOffs*Size*0.5,"
" 1.0"
" );"
"}"
).Compile();
cloud_gs.Source(
"#version 330\n"
"layout(points) in;"
"layout(triangle_strip, max_vertices = 4) out;"
"in float vertZOffs[];"
"in float vertSize[];"
"uniform vec3 LightPos;"
"uniform mat4 CameraMatrix, ProjectionMatrix;"
"uniform vec4 ViewX, ViewY, ViewZ;"
"out vec3 geomTexCoord;"
"out vec3 geomLightDir;"
"void main(void)"
"{"
" float zo = vertZOffs[0];"
" float s = vertSize[0];"
" float yo[2] = float[2](-1.0, 1.0);"
" float xo[2] = float[2](-1.0, 1.0);"
" for(int j=0;j!=2;++j)"
" for(int i=0;i!=2;++i)"
" {"
" vec4 v = vec4("
" gl_in[0].gl_Position.xyz+"
" ViewX.xyz * xo[i] * s * 0.5+"
" ViewY.xyz * yo[j] * s * 0.5,"
" 1.0"
" );"
" gl_Position = ProjectionMatrix * CameraMatrix * v;"
" geomLightDir = LightPos - v.xyz;"
" geomTexCoord = "
" vec3(0.5, 0.5, 0.5)+"
" ViewX.xyz*(xo[i])*0.707+"
" ViewY.xyz*(yo[j])*0.707+"
" ViewZ.xyz*(zo )*0.707;"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
).Compile();
cloud_fs.Source(
"#version 330\n"
"uniform sampler3D CloudTex;"
"in vec3 geomTexCoord;"
"in vec3 geomLightDir;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float d = texture(CloudTex, geomTexCoord).r;"
" float o = 1.0;"
" float s = 2.0/128.0;"
" float r = s * 8.0;"
" vec3 sampleOffs = normalize(geomLightDir) * s;"
" vec3 samplePos = geomTexCoord;"
" if(d > 0.01) while(o > 0.0)"
" {"
" if(samplePos.x<0.0 || samplePos.x>1.0)"
" break;"
" if(samplePos.y<0.0 || samplePos.y>1.0)"
" break;"
" if(samplePos.z<0.0 || samplePos.z>1.0)"
" break;"
" o -= texture(CloudTex, samplePos).r*r;"
" samplePos += sampleOffs;"
" }"
" float a = 0.4 * d;"
" float i = mix(0.2, 1.0, o);"
" fragColor = vec4(i, i, i, a);"
"}"
).Compile();
cloud_prog << cloud_vs << cloud_gs << cloud_fs;
cloud_prog.Link().Use();
// bind the VAO for the clouds
clouds.Bind();
// bind the VBO for the cloud positions
pos_buffer.Bind(Buffer::Target::Array);
{
Buffer::Data(Buffer::Target::Array, positions);
(cloud_prog|"Position").Setup(3, DataType::Float).Enable();
}
// bind the VBO for the cloud sizes
size_buffer.Bind(Buffer::Target::Array);
{
Buffer::Data(Buffer::Target::Array, sizes);
(cloud_prog|"Size").Setup(1, DataType::Float).Enable();
}
// set the number of samples
cloud_prog/"SampleCount" = GLint(samples);
Texture::Active(0);
cloud_prog/"CloudTex" = 0;
for(std::size_t i=0, n=positions.size(); i!=n; ++i)
{
auto bound_tex = Bind(cloud_tex[i], Texture::Target::_3D);
bound_tex.Image3D(
images::Cloud(
128, 128, 128,
Vec3f(0.1f, -0.5f, 0.3f),
0.5f
)
);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.BorderColor(Vec4f(0.0f, 0.0f, 0.0f, 0.0f));
bound_tex.WrapS(TextureWrap::ClampToBorder);
bound_tex.WrapT(TextureWrap::ClampToBorder);
bound_tex.WrapR(TextureWrap::ClampToBorder);
}
gl.ClearColor(0.0f, 0.1f, 0.2f, 0.0f);
gl.ClearDepth(1.0f);
gl.Disable(Capability::DepthTest);
gl.Enable(Capability::Blend);
gl.BlendFunc(BlendFn::SrcAlpha, BlendFn::OneMinusSrcAlpha);
}
WavesExample(void)
: make_plane(
Vec3f( 0.0f, 0.0f, 0.0f),
Vec3f(100.0f, 0.0f, 0.0f),
Vec3f( 0.0f, 0.0f,-100.0f),
50, 50
), plane_instr(make_plane.PatchInstructions())
, plane_indices(make_plane.PatchIndices())
, camera_matrix(prog, "CameraMatrix")
, camera_position(prog, "CameraPosition")
, anim_time(prog, "Time")
, prev_period(-1)
{
VertexShader vs(ObjectDesc("Vertex"));
vs.Source(StrLit(
"#version 410\n"
"uniform vec3 CameraPosition;"
"in vec3 Position;"
"out vec3 vertPosition;"
"out float vertDistance;"
"void main(void)"
"{"
" vertPosition = Position;"
" vertDistance = distance(CameraPosition, Position);"
"}"
));
vs.Compile();
prog.AttachShader(vs);
TessControlShader cs(ObjectDesc("TessControl"));
cs.Source(
"#version 410\n"
"layout(vertices = 3) out;"
"in vec3 vertPosition[];"
"in float vertDistance[];"
"out vec3 tecoPosition[];"
"int tessLevel(float dist)"
"{"
" return clamp(int(150.0 / (dist+0.1)), 1, 10);"
"}"
"void main(void)"
"{"
" tecoPosition[gl_InvocationID] ="
" vertPosition[gl_InvocationID];"
" if(gl_InvocationID == 0)"
" {"
" gl_TessLevelInner[0] = tessLevel(("
" vertDistance[0]+"
" vertDistance[1]+"
" vertDistance[2] "
" )*0.333);"
" gl_TessLevelOuter[0] = tessLevel(("
" vertDistance[1]+"
" vertDistance[2] "
" )*0.5);"
" gl_TessLevelOuter[1] = tessLevel(("
" vertDistance[2]+"
" vertDistance[0] "
" )*0.5);"
" gl_TessLevelOuter[2] = tessLevel(("
" vertDistance[0]+"
" vertDistance[1] "
" )*0.5);"
" }"
"}"
);
cs.Compile();
prog.AttachShader(cs);
TessEvaluationShader es(ObjectDesc("TessEvaluation"));
es.Source(
"#version 410\n"
"#define MaxWaves 5\n"
"layout(triangles, equal_spacing, ccw) in;"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"uniform vec3 LightPosition;"
"uniform vec3 CameraPosition;"
"uniform float Time;"
"uniform int WaveCount;"
"uniform vec3 WaveDirections[MaxWaves];"
"uniform vec3 WaveDimensions[MaxWaves];"
"in vec3 tecoPosition[];"
"out vec3 teevNormal;"
"out vec3 teevLightDir;"
"out vec3 teevViewDir;"
"out float teevDistance;"
"void main(void)"
"{"
" const vec3 Up = vec3(0.0, 1.0, 0.0);"
" vec3 Position ="
" gl_TessCoord.x * tecoPosition[0]+"
" gl_TessCoord.y * tecoPosition[1]+"
" gl_TessCoord.z * tecoPosition[2];"
" vec3 Pos = Position;"
" vec3 Nml = Up;"
" for(int w=0; w!=WaveCount; ++w)"
" {"
" vec3 Dir = WaveDirections[w];"
" vec3 Dim = WaveDimensions[w];"
" float Dist = dot(Position, Dir);"
" float u = Dim.y*sin(Dist/Dim.x + Time*Dim.z);"
" Pos += Up * u;"
" float w = (Dim.y/Dim.x)*cos(Dist/Dim.x + Time*Dim.z);"
" Nml -= Dir * w;"
" float d = -0.125*Dim.x*sin(2.0*Dist/Dim.x + Time*Dim.z);"
" Pos += Dir * d;"
" }"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" vec4(Pos, 1.0);"
" teevNormal = normalize(Nml);"
" teevLightDir = normalize(LightPosition - Pos);"
" teevViewDir = normalize(CameraPosition - Pos);"
" teevDistance = distance(CameraPosition, Pos);"
"}"
);
es.Compile();
prog.AttachShader(es);
FragmentShader fs(ObjectDesc("Fragment"));
fs.Source(StrLit(
"#version 410\n"
"uniform samplerCube EnvMap;"
"in vec3 teevNormal;"
"in vec3 teevLightDir;"
"in vec3 teevViewDir;"
"in float teevDistance;"
"out vec3 fragColor;"
"void main(void)"
"{"
" float Dim = clamp(30.0/teevDistance, 0.0, 1.0);"
" float LightRefl = dot(reflect(-teevLightDir, teevNormal), teevViewDir);"
" float LightHit = dot(teevNormal, teevLightDir);"
" float Diffuse = clamp(LightHit+0.1, 0.0, 1.0);"
" float Specular = pow(clamp(LightRefl, 0.0, 0.91), 32);"
" vec3 Environ=texture(EnvMap,reflect(-teevViewDir, teevNormal)).rgb;"
" vec3 WaterColor = vec3(0.4, 0.5, 0.5);"
" vec3 LightColor = vec3(1.0, 1.0, 1.0);"
" vec3 FogColor = vec3(0.9, 0.9, 0.9);"
" vec3 WaveColor ="
" LightColor*Specular+"
" WaterColor*Diffuse+"
" Environ*0.02;"
" fragColor = mix(WaveColor, FogColor, 1.0-Dim);"
"}"
));
fs.Compile();
prog.AttachShader(fs);
prog.Link();
prog.Use();
plane.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_plane.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
Uniform<Vec3f>(prog, "LightPosition").Set(-100.0, 100.0, 20.0);
Uniform<Vec3f> wave_directions(prog, "WaveDirections");
Uniform<Vec3f> wave_dimensions(prog, "WaveDimensions");
Uniform<GLint>(prog, "WaveCount").Set(5);
wave_directions[0] = Normalized(Vec3f(1.0f, 0.0f, 1.0f));
wave_dimensions[0] = Vec3f(5.0f, 1.5f, 1.2f);
wave_directions[1] = Normalized(Vec3f(1.0f, 0.0f, 0.5f));
wave_dimensions[1] = Vec3f(4.0f, 0.8f, 1.2f);
wave_directions[2] = Normalized(Vec3f(1.0f, 0.0f, 0.1f));
wave_dimensions[2] = Vec3f(2.0f, 0.5f, 2.4f);
wave_directions[3] = Normalized(Vec3f(1.0f, 0.0f,-0.1f));
wave_dimensions[3] = Vec3f(1.5f, 0.2f, 3.7f);
wave_directions[4] = Normalized(Vec3f(1.0f, 0.0f, 0.4f));
wave_dimensions[4] = Vec3f(1.1f, 0.2f, 4.7f);
Texture::Active(0);
{
auto image = images::Squares(512, 512, 0.9f, 16, 16);
auto bound_tex = Bind(env_map, Texture::Target::CubeMap);
for(int i=0; i!=6; ++i)
Texture::Image2D(Texture::CubeMapFace(i), image);
bound_tex.GenerateMipmap();
bound_tex.MinFilter(TextureMinFilter::LinearMipmapLinear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
bound_tex.SwizzleG(TextureSwizzle::Red);
bound_tex.SwizzleB(TextureSwizzle::Red);
}
UniformSampler(prog, "EnvMap").Set(0);
gl.ClearColor(0.9f, 0.9f, 0.9f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
MultiViewportExample(void)
: make_shape(1.0, 0.1, 8, 4, 48)
, shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, camera_position_3(prog, "CameraPosition[3]")
, camera_matrix_0(prog, "CameraMatrix[0]")
, camera_matrix_1(prog, "CameraMatrix[1]")
, camera_matrix_2(prog, "CameraMatrix[2]")
, camera_matrix_3(prog, "CameraMatrix[3]")
, model_matrix(prog, "ModelMatrix")
{
VertexShader vs;
// Set the vertex shader source
vs.Source(
"#version 330\n"
"uniform mat4 ModelMatrix;"
"uniform vec3 LightPos;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"out vec3 vertTexCoord;"
"out vec3 vertLightDir;"
"out vec3 vertLightRefl;"
"void main(void)"
"{"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertTexCoord = Normal;"
" gl_Position = ModelMatrix * Position;"
" vertLightDir = LightPos-gl_Position.xyz;"
" vertLightRefl = reflect(-vertLightDir, vertNormal);"
"}"
);
vs.Compile();
GeometryShader gs;
// Set the geometry shader source
gs.Source(
"#version 330\n"
"#extension GL_ARB_viewport_array : enable\n"
"layout(triangles) in;"
"layout(triangle_strip, max_vertices = 12) out;"
"uniform mat4 CameraMatrix[4];"
"uniform vec3 CameraPosition[4];"
"in vec3 vertNormal[];"
"in vec3 vertTexCoord[];"
"in vec3 vertLightDir[];"
"in vec3 vertLightRefl[];"
"out vec3 geomNormal;"
"out vec3 geomTexCoord;"
"out vec3 geomLightDir;"
"out vec3 geomLightRefl;"
"out vec3 geomViewDir;"
"out vec3 geomViewRefl;"
"void main(void)"
"{"
" for(int vp=0; vp!=4; ++vp)"
" {"
" gl_ViewportIndex = vp;"
" for(int v=0; v!=3; ++v)"
" {"
" geomNormal = vertNormal[v];"
" geomTexCoord = vertTexCoord[v];"
" geomLightDir = vertLightDir[v];"
" geomLightRefl = vertLightRefl[v];"
" geomViewDir = "
" CameraPosition[vp] - "
" gl_in[v].gl_Position.xyz;"
" geomViewRefl = reflect("
" -geomViewDir,"
" geomNormal"
" );"
" gl_Position = "
" CameraMatrix[vp] *"
" gl_in[v].gl_Position;"
" EmitVertex();"
" }"
" EndPrimitive();"
" }"
"}"
);
gs.Compile();
FragmentShader fs;
// set the fragment shader source
fs.Source(
"#version 330\n"
"uniform samplerCube TexUnit;"
"in vec3 geomNormal;"
"in vec3 geomTexCoord;"
"in vec3 geomLightDir;"
"in vec3 geomLightRefl;"
"in vec3 geomViewDir;"
"in vec3 geomViewRefl;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = length(geomLightDir);"
" float d = dot("
" normalize(geomNormal), "
" normalize(geomLightDir)"
" ) / l;"
" float s = dot("
" normalize(geomLightRefl),"
" normalize(geomViewDir)"
" );"
" vec3 lt = vec3(1.0, 1.0, 1.0);"
" vec3 tex = texture(TexUnit, geomTexCoord).rgb;"
" fragColor = vec4("
" tex * 0.4 + "
" (lt + tex) * 1.5 * max(d, 0.0) + "
" lt * pow(max(s, 0.0), 64), "
" 1.0"
" );"
"}"
);
// compile it
fs.Compile();
// attach the shaders to the program
prog.AttachShader(vs);
prog.AttachShader(gs);
prog.AttachShader(fs);
// link and use it
prog.Link();
prog.Use();
// bind the VAO for the shape
shape.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribArray attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
{
GLuint tex_side = 512;
auto image = images::NewtonFractal(
tex_side, tex_side,
Vec3f(0.8f, 0.8f, 1.0f),
Vec3f(0.1f, 0.0f, 0.2f),
Vec2f(-0.707f, -0.707f),
Vec2f( 0.707f, 0.707f),
images::NewtonFractal::X4Minus1(),
[](double x) -> double
{
return pow(SineWave(pow(x,0.5)), 4.0);
}
);
auto bound_tex = Bind(tex, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
for(int i=0; i!=6; ++i)
Texture::Image2D(Texture::CubeMapFace(i), image);
}
//
UniformSampler(prog, "TexUnit").Set(0);
Uniform<Vec3f>(prog, "LightPos").Set(Vec3f(3.0f, 5.0f, 4.0f));
//
gl.ClearColor(0.1f, 0.05f, 0.2f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
gl.CullFace(Face::Back);
Uniform<Vec3f> camera_position(prog, "CameraPosition");
camera_position[0].Set(Vec3f(2, 0, 0));
camera_position[1].Set(Vec3f(0, 2, 0));
camera_position[2].Set(Vec3f(0, 0, 2));
}
ShadowVolExample(const ExampleParams& params)
: shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, shape_vs(ShaderType::Vertex, ObjectDesc("Shape vertex"))
, depth_vs(ShaderType::Vertex, ObjectDesc("Depth vertex"))
, light_vs(ShaderType::Vertex, ObjectDesc("Light vertex"))
, depth_gs(ShaderType::Geometry, ObjectDesc("Depth geometry"))
, light_gs(ShaderType::Geometry, ObjectDesc("Light geometry"))
, shape_fs(ShaderType::Fragment, ObjectDesc("Shape fragment"))
, depth_fs(ShaderType::Fragment, ObjectDesc("Depthfragment"))
, light_fs(ShaderType::Fragment, ObjectDesc("Light fragment"))
, shape_prog(ObjectDesc("Shape"))
, depth_prog(ObjectDesc("Depth"))
, light_prog(ObjectDesc("Light"))
, tex_side(128)
, sample_count(params.HighQuality()?1024:128)
{
shape_vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out vec3 vertNormal;"
"out vec3 vertLightDir;"
"out vec3 vertLightRefl;"
"out vec3 vertViewDir;"
"out vec3 vertViewRefl;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLightDir = LightPos - gl_Position.xyz;"
" vertLightRefl = reflect("
" -normalize(vertLightDir),"
" normalize(vertNormal)"
" );"
" vertViewDir = (vec4(0.0, 0.0, 1.0, 1.0)* CameraMatrix).xyz;"
" vertViewRefl = reflect("
" normalize(vertViewDir),"
" normalize(vertNormal)"
" );"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
);
shape_vs.Compile();
shape_fs.Source(
"#version 330\n"
"in vec3 vertNormal;"
"in vec3 vertLightDir;"
"in vec3 vertLightRefl;"
"in vec3 vertViewDir;"
"in vec3 vertViewRefl;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = length(vertLightDir);"
" float d = dot("
" normalize(vertNormal), "
" normalize(vertLightDir)"
" ) / l;"
" float s = dot("
" normalize(vertLightRefl),"
" normalize(vertViewDir)"
" );"
" vec3 ambi = vec3(0.6, 0.3, 0.5);"
" vec3 diff = vec3(0.9, 0.7, 0.8);"
" vec3 spec = vec3(1.0, 0.9, 0.95);"
" fragColor = vec4("
" ambi * 0.3 + "
" diff * 0.7 * max(d, 0.0) + "
" spec * pow(max(s, 0.0), 64), "
" 1.0"
" );"
"}"
);
shape_fs.Compile();
shape_prog.AttachShader(shape_vs);
shape_prog.AttachShader(shape_fs);
shape_prog.Link();
depth_vs.Source(
"#version 330\n"
"uniform mat4 ModelMatrix;"
"uniform vec3 LightPos;"
"in vec4 Position;"
"void main(void)"
"{"
" gl_Position = "
" mat4("
" 1.0, 0.0, 0.0, -LightPos.x,"
" 0.0, 1.0, 0.0, -LightPos.y,"
" 0.0, 0.0, 1.0, -LightPos.z,"
" 0.0, 0.0, 0.0, 1.0"
" )*"
" ModelMatrix *"
" mat4("
" 10.0, 0.0, 0.0, 0.0,"
" 0.0, 10.0, 0.0, 0.0,"
" 0.0, 0.0, 10.0, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" )*"
" Position;"
"}"
);
depth_vs.Compile();
depth_gs.Source(
"#version 330\n"
"layout(triangles) in;"
"layout(triangle_strip, max_vertices = 18) out;"
"uniform mat4 ProjectionMatrix;"
"const mat4 CubeFaceMatrix[6] = mat4[6]("
" mat4("
" 0.0, 0.0, -1.0, 0.0,"
" 0.0, -1.0, 0.0, 0.0,"
" -1.0, 0.0, 0.0, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ), mat4("
" 0.0, 0.0, 1.0, 0.0,"
" 0.0, -1.0, 0.0, 0.0,"
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ), mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 0.0, -1.0, 0.0,"
" 0.0, 1.0, 0.0, 0.0,"
" 0.0, 0.0, 0.0, 1.0 "
" ), mat4("
" 1.0, 0.0, 0.0, 0.0,"
" 0.0, 0.0, 1.0, 0.0,"
" 0.0, -1.0, 0.0, 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,"
" 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,"
" 0.0, 0.0, 0.0, 1.0 "
" )"
");"
"void main(void)"
"{"
" for(gl_Layer=0; gl_Layer!=6; ++gl_Layer)"
" {"
" for(int i=0; i!=3; ++i)"
" {"
" gl_Position = "
" ProjectionMatrix *"
" CubeFaceMatrix[gl_Layer]*"
" gl_in[i].gl_Position;"
" EmitVertex();"
" }"
" EndPrimitive();"
" }"
"}"
);
depth_gs.Compile();
depth_fs.Source(
"#version 330\n"
"void main(void)"
"{"
" gl_FragDepth = gl_FragCoord.z;"
"}"
);
depth_fs.Compile();
depth_prog.AttachShader(depth_vs);
depth_prog.AttachShader(depth_gs);
depth_prog.AttachShader(depth_fs);
depth_prog.Link();
depth_prog.Use();
Uniform<Mat4f>(depth_prog, "ProjectionMatrix").Set(
CamMatrixf::PerspectiveX(
RightAngles(1.0),
1.0,
0.1,
10.0
)
);
// bind the VAO for the shape
shape.Bind();
shape_positions.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexAttribSlot location;
if(VertexAttribArray::QueryCommonLocation(
"Position",
location,
shape_prog,
depth_prog
))
{
VertexAttribArray shape_attr(location);
shape_attr.Setup(n_per_vertex, DataType::Float);
shape_attr.Enable();
}
else assert(!"Inconsistent 'Position' location");
}
shape_normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
shape_prog.Use();
VertexAttribArray attr(shape_prog, "Normal");
attr.Setup(n_per_vertex, DataType::Float);
attr.Enable();
}
light_vs.Source(
"#version 330\n"
"in vec3 Position;"
"out float vertZOffs;"
"uniform vec3 LightPos;"
"uniform int SampleCount;"
"void main(void)"
"{"
" float hp = (SampleCount-1) * 0.5;"
" vertZOffs = (gl_InstanceID - hp)/hp;"
" gl_Position = vec4(Position + LightPos, 1.0);"
"}"
);
light_vs.Compile();
light_gs.Source(
"#version 330\n"
"layout(points) in;"
"layout(triangle_strip, max_vertices = 4) out;"
"in float vertZOffs[];"
"out vec4 geomPosition;"
"uniform mat4 CameraMatrix, ProjectionMatrix;"
"uniform vec3 ViewX, ViewY, ViewZ;"
"uniform float LightVolSize;"
"void main(void)"
"{"
" float zo = vertZOffs[0];"
" float yo[2] = float[2](-1.0, 1.0);"
" float xo[2] = float[2](-1.0, 1.0);"
" for(int j=0;j!=2;++j)"
" for(int i=0;i!=2;++i)"
" {"
" geomPosition = vec4("
" gl_in[0].gl_Position.xyz+"
" ViewX * xo[i] * LightVolSize+"
" ViewY * yo[j] * LightVolSize+"
" ViewZ * zo * LightVolSize,"
" 1.0"
" );"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" geomPosition;"
" EmitVertex();"
" }"
" EndPrimitive();"
"}"
);
light_gs.Compile();
light_fs.Source(
"#version 330\n"
"in vec4 geomPosition;"
"out vec4 fragColor;"
"uniform samplerCubeShadow ShadowMap;"
"uniform int SampleCount;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" vec3 LightDir = geomPosition.xyz - LightPos;"
" vec4 ShadowCoord = vec4("
" normalize(LightDir),"
" length(LightDir)"
" );"
" float s = texture(ShadowMap, ShadowCoord);"
" float alpha = s / (SampleCount * pow(length(LightDir), 2));"
" fragColor = vec4(1.0, 1.0, 1.0, alpha);"
"}"
);
light_fs.Compile();
light_prog.AttachShader(light_vs);
light_prog.AttachShader(light_gs);
light_prog.AttachShader(light_fs);
light_prog.Link();
light_prog.Use();
// bind the VAO for the light volume
light.Bind();
// bind the VBO for the light volume plane positions
light_positions.Bind(Buffer::Target::Array);
{
GLfloat position[3] = {0.0, 0.0, 0.0};
Buffer::Data(Buffer::Target::Array, 3, position);
VertexAttribArray attr(light_prog, "Position");
attr.Setup(3, DataType::Float);
attr.Enable();
}
Uniform<GLint>(light_prog, "SampleCount").Set(sample_count);
Uniform<GLfloat>(light_prog, "LightVolSize").Set(4);
UniformSampler(light_prog, "ShadowMap").Set(0);
// Setup the texture and the offscreen FBO
Texture::Active(0);
{
auto bound_tex = Bind(depth_tex, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
bound_tex.CompareFunc(CompareFunction::LEqual);
bound_tex.CompareMode(
TextureCompareMode::CompareRefToTexture
);
for(int i=0; i!=6; ++i)
{
Texture::Image2D(
Texture::CubeMapFace(i),
0,
PixelDataInternalFormat::DepthComponent,
tex_side, tex_side,
0,
PixelDataFormat::DepthComponent,
PixelDataType::Float,
nullptr
);
}
auto bound_fbo = Bind(
depth_fbo,
Framebuffer::Target::Draw
);
bound_fbo.AttachTexture(
FramebufferAttachment::Depth,
depth_tex,
0
);
}
//
gl.ClearColor(0.2f, 0.05f, 0.1f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
gl.CullFace(Face::Back);
gl.BlendFunc(BlendFunction::SrcAlpha, BlendFunction::One);
}
SkyBoxExample(void)
: prog()
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
{
VertexShader vs;
vs.Source(StrLit(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix;"
"mat4 Matrix = ProjectionMatrix*CameraMatrix;"
"in vec3 Corner;"
"out vec3 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = Matrix * vec4(Corner * 10.0, 1.0);"
" vertTexCoord = Corner;"
"}"
));
vs.Compile();
prog.AttachShader(vs);
FragmentShader fs;
fs.Source(StrLit(
"#version 330\n"
"uniform samplerCube EnvMap;"
"in vec3 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" fragColor = vec4(texture(EnvMap, normalize(vertTexCoord)).rgb, 1.0);"
"}"
));
fs.Compile();
prog.AttachShader(fs);
prog.Link();
prog.Use();
sky_box.Bind();
GLfloat sky_box_corners[8*3] = {
-1.0f,-1.0f,-1.0f,
+1.0f,-1.0f,-1.0f,
-1.0f,+1.0f,-1.0f,
+1.0f,+1.0f,-1.0f,
-1.0f,-1.0f,+1.0f,
+1.0f,-1.0f,+1.0f,
-1.0f,+1.0f,+1.0f,
+1.0f,+1.0f,+1.0f
};
corners.Bind(Buffer::Target::Array);
Buffer::Data(Buffer::Target::Array, sky_box_corners);
VertexAttribArray vert_attr(prog, "Corner");
vert_attr.Setup(3, DataType::Float).Enable();
GLuint sky_box_indices[6*5] = {
1, 3, 5, 7, 9,
4, 6, 0, 2, 9,
2, 6, 3, 7, 9,
4, 0, 5, 1, 9,
5, 7, 4, 6, 9,
0, 2, 1, 3, 9
};
indices.Bind(Buffer::Target::ElementArray);
Buffer::Data(Buffer::Target::ElementArray, 6*5, sky_box_indices);
gl.Enable(Capability::PrimitiveRestart);
gl.PrimitiveRestartIndex(9);
{
UniformSampler(prog, "EnvMap").Set(0);
Texture::Active(0);
auto bound_tex = oglplus::Bind(env_map, Texture::Target::CubeMap);
bound_tex.MinFilter(TextureMinFilter::Linear);
bound_tex.MagFilter(TextureMagFilter::Linear);
bound_tex.WrapS(TextureWrap::ClampToEdge);
bound_tex.WrapT(TextureWrap::ClampToEdge);
bound_tex.WrapR(TextureWrap::ClampToEdge);
Texture::Image2D(
Texture::CubeMapFace(0),
images::LoadTexture("cloudy_day-cm_0", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(1),
images::LoadTexture("cloudy_day-cm_1", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(2),
images::LoadTexture("cloudy_day-cm_2", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(3),
images::LoadTexture("cloudy_day-cm_3", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(4),
images::LoadTexture("cloudy_day-cm_4", false, false)
);
Texture::Image2D(
Texture::CubeMapFace(5),
images::LoadTexture("cloudy_day-cm_5", false, false)
);
}
gl.ClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.ClearDepth(1.0f);
}
