void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer().StencilBuffer();
// make the camera matrix orbiting around the origin
// at radius of 3.5 with elevation between 15 and 90 degrees
camera_matrix.Set(
CamMatrixf::Orbiting(
Vec3f(),
5.0,
Degrees(time * 11),
Degrees(15 + (-SineWave(0.25+time/12.5)+1.0)*0.5*75)
)
);
ModelMatrixf identity;
// make the model transformation matrix
ModelMatrixf model =
ModelMatrixf::Translation(0.0f, 1.5f, 0.0) *
ModelMatrixf::RotationZ(Degrees(time * 43))*
ModelMatrixf::RotationY(Degrees(time * 63))*
ModelMatrixf::RotationX(Degrees(time * 79));
// make the reflection matrix
auto reflection = ModelMatrixf::Reflection(false, true, false);
//
gl.Disable(Capability::Blend);
gl.Disable(Capability::DepthTest);
gl.Enable(Capability::StencilTest);
gl.ColorMask(false, false, false, false);
gl.StencilFunc(CompareFunction::Always, 1, 1);
gl.StencilOp(StencilOp::Keep, StencilOp::Keep, StencilOp::Replace);
gl.Bind(plane);
model_matrix.Set(identity);
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
gl.ColorMask(true, true, true, true);
gl.Enable(Capability::DepthTest);
gl.StencilFunc(CompareFunction::Equal, 1, 1);
gl.StencilOp(StencilOp::Keep, StencilOp::Keep, StencilOp::Keep);
// draw the cube using the reflection program
model_matrix.Set(reflection * model);
gl.Bind(cube);
cube_instr.Draw(cube_indices);
gl.Disable(Capability::StencilTest);
// draw the cube using the normal object program
model_matrix.Set(model);
cube_instr.Draw(cube_indices);
// blend-in the plane
gl.Enable(Capability::Blend);
gl.BlendEquation(BlendEquation::Max);
gl.Bind(plane);
model_matrix.Set(identity);
gl.DrawArrays(PrimitiveType::TriangleStrip, 0, 4);
}
DrawProc(const Particles& particles)
{
gl.Bind(vao);
gl.Bind(BufferTarget::ElementArray, particles.indices_d);
gl.Bind(BufferTarget::Array, particles.positions);
(prog|"Position").Setup<Vec3f>().Enable();
gl.Bind(NoVertexArray());
}
DistProc(const Particles& particles)
{
gl.Bind(vao);
gl.Bind(BufferTarget::Array, particles.positions);
(prog|"Position").Setup<Vec3f>().Enable();
gl.Bind(NoVertexArray());
gl.Bind(BufferIndexedTarget::TransformFeedback, 0, particles.indices_f);
gl.Bind(BufferIndexedTarget::TransformFeedback, 1, particles.distances);
}
void Render(double time)
{
static const Mat4f reflection(
Vec4f( 1.0, 0.0, 0.0, 0.0),
Vec4f( 0.0,-1.0, 0.0, 0.0),
Vec4f( 0.0, 0.0, 1.0, 0.0),
Vec4f( 0.0, 0.0, 0.0, 1.0)
);
auto camera = CamMatrixf::Orbiting(
Vec3f(),
GLfloat(7.0 + SineWave(time / 12.0)*2.5),
FullCircles(time / 10.0),
Degrees(45.0 - SineWave(time / 7.0)*35.0)
);
shape_prog.Use();
shape.Bind();
gl.Enable(Capability::CullFace);
gl.FrontFace(make_shape.FaceWinding());
// render into the off-screen framebuffer
fbo.Bind(Framebuffer::Target::Draw);
gl.Viewport(
(width - refl_tex_side) / 2,
(height - refl_tex_side) / 2,
refl_tex_side, refl_tex_side
);
gl.Clear().ColorBuffer().DepthBuffer();
shape_camera_matrix.Set(
camera *
ModelMatrixf::Translation(0.0f, -1.0f, 0.0f) *
reflection
);
gl.CullFace(Face::Front);
shape_instr.Draw(shape_indices);
gl.Bind(Framebuffer::Target::Draw, DefaultFramebuffer());
gl.Viewport(width, height);
gl.Clear().ColorBuffer().DepthBuffer();
shape_camera_matrix.Set(camera);
gl.CullFace(Face::Back);
shape_instr.Draw(shape_indices);
gl.Disable(Capability::CullFace);
// Render the plane
plane_prog.Use();
plane.Bind();
plane_camera_matrix.Set(camera);
plane_camera_position.Set(camera.Position());
plane_instr.Draw(plane_indices);
}
void operator()(const Particles& particles)
{
gl.Enable(Capability::Blend);
gl.Bind(vao);
gl.Use(prog);
gl.DrawElements(PrimitiveType::Points, particles.Count(), (GLuint*)0);
gl.Disable(Capability::Blend);
}
void operator()(const Particles& particles)
{
gl.Bind(vao);
gl.Use(prog);
xfb.BeginPoints();
gl.DrawArrays(PrimitiveType::Points, 0, particles.Count());
xfb.End();
}
SortProc(const Particles& particles)
{
gl.Bind(vao);
gl.Bind(BufferTarget::Array, particles.indices_d);
(prog|"Index").Setup<GLint>().Enable();
gl.Bind(NoVertexArray());
gl.Bind(BufferIndexedTarget::TransformFeedback, 0, particles.indices_f);
gl.Bind(BufferIndexedTarget::Uniform, 0, particles.indices_d);
gl.Bind(BufferIndexedTarget::Uniform, 1, particles.distances);
gl.Use(prog);
UniformBlock(prog,"IndexBlock").Binding(0);
UniformBlock(prog, "DistBlock").Binding(1);
gl.Use(NoProgram());
}
void HSWDisplay::UnloadGraphics()
{
if(pTexture) // If initialized...
{
Context currentGLContext;
currentGLContext.InitFromCurrent();
GLContext.Bind();
// RenderParams: No need to clear.
if(FrameBuffer != 0)
{
glDeleteFramebuffers(1, &FrameBuffer);
FrameBuffer = 0;
}
pTexture.Clear();
pShaderSet.Clear();
pVertexShader.Clear();
pFragmentShader.Clear();
pVB.Clear();
if(VAO)
{
#ifdef OVR_OS_MAC
if(GLVersionInfo.WholeVersion >= 302)
glDeleteVertexArrays(1, &VAO);
else
glDeleteVertexArraysAPPLE(1, &VAO);
#else
glDeleteVertexArrays(1, &VAO);
#endif
VAO = 0;
VAOInitialized = false;
}
// OrthoProjection: No need to clear.
currentGLContext.Bind();
GLContext.Destroy();
}
}
void operator()(const Particles& particles)
{
gl.Bind(vao);
gl.Use(prog);
for(GLuint p=0; p!=particles.sort_nw.PassCount(); ++p)
{
Buffer::CopySubData(
BufferTarget::CopyRead,
BufferTarget::CopyWrite,
0, 0, particles.Count()*sizeof(GLuint)
);
prog.pass.Set(p);
xfb.BeginPoints();
gl.DrawArrays(PrimitiveType::Points, 0, particles.Count());
xfb.End();
}
Buffer::CopySubData(
BufferTarget::CopyRead,
BufferTarget::CopyWrite,
0, 0, particles.Count()*sizeof(GLint)
);
}
void Render(double time)
{
gl.Clear().ColorBuffer().DepthBuffer();
//
auto camera = CamMatrixf::Orbiting(
Vec3f(),
5.5,
FullCircles(time / 10.0),
Degrees(45.0 + SineWave(time / 7.0)*30.0)
);
// Render the plane
plane_prog.Use();
plane_camera_matrix.Set(camera);
plane_model_matrix.Set(
ModelMatrixf::Translation(0.0f, -1.1f, 0.0f)
);
gl.Bind(plane);
plane_instr.Draw(plane_indices);
// Render the shape
shape_prog.Use();
auto clip_plane = Planef::FromNormal(Vec3f(Data(camera.Row(2)), 3));
shape_clip_plane.Set(clip_plane.Equation());
shape_camera_matrix.Set(camera);
shape_model_matrix.Set(
ModelMatrixf::RotationX(FullCircles(time / 12.0))
);
gl.Bind(shape);
gl.Enable(Capability::CullFace);
gl.Enable(Functionality::ClipDistance, 0);
gl.FrontFace(make_shape.FaceWinding());
GLfloat clip_dirs[2] = {-1.0f, 1.0f};
Face facing_dirs[2] = {Face::Front, Face::Back};
for(int c=0; c!=2; ++c)
{
shape_clip_direction.Set(clip_dirs[c]);
for(int f=0; f!=2; ++f)
{
Texture::CopyImage2D(
Texture::Target::_2D,
0,
PixelDataInternalFormat::RGB,
tex_side == width ? 0 : (width - tex_side) / 2,
tex_side == height? 0 : (height- tex_side) / 2,
tex_side, tex_side,
0
);
gl.CullFace(facing_dirs[f]);
shape_instr.Draw(shape_indices);
}
}
gl.Disable(Functionality::ClipDistance, 0);
gl.Disable(Capability::CullFace);
}
ReflectionExample(void)
: make_cube(0.5,0.5,0.5, 0.1,0.1,0.1, 3,3,3)
, cube_indices(make_cube.Indices())
, cube_instr(make_cube.Instructions())
, prog(make_prog())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
gl.Use(prog);
// bind the VAO for the cube
gl.Bind(cube);
// bind the VBO for the cube vertices
gl.Bind(Buffer::Target::Array, cube_verts);
{
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
gl.Bind(Buffer::Target::Array, cube_normals);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_cube.Normals(data);
// upload the data
Buffer::Data(Buffer::Target::Array, data);
// setup the vertex attribs array for the normals
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VAO for the plane
gl.Bind(plane);
// bind the VBO for the plane vertices
gl.Bind(Buffer::Target::Array, plane_verts);
{
GLfloat data[4*3] = {
-2.0f, 0.0f, 2.0f,
-2.0f, 0.0f, -2.0f,
2.0f, 0.0f, 2.0f,
2.0f, 0.0f, -2.0f
};
// upload the data
Buffer::Data(Buffer::Target::Array, 4*3, data);
// setup the vertex attribs array for the vertices
prog.Use();
VertexArrayAttrib attr(prog, "Position");
attr.Setup<Vec3f>();
attr.Enable();
}
// bind the VBO for the cube normals
gl.Bind(Buffer::Target::Array, plane_normals);
{
GLfloat data[4*3] = {
-0.1f, 1.0f, 0.1f,
-0.1f, 1.0f, -0.1f,
0.1f, 1.0f, 0.1f,
0.1f, 1.0f, -0.1f
};
// upload the data
Buffer::Data(Buffer::Target::Array, 4*3, data);
// setup the vertex attribs array for the normals
prog.Use();
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<Vec3f>();
attr.Enable();
}
gl.Bind(NoVertexArray());
Uniform<Vec3f>(prog, "LightPos").Set(1.5, 2.0, 2.5);
//
gl.ClearColor(0.2f, 0.2f, 0.2f, 0.0f);
gl.ClearDepth(1.0f);
gl.ClearStencil(0);
}
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())
, 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());
}
void HSWDisplay::RenderInternal(ovrEyeType eye, const ovrTexture* eyeTexture)
{
if(RenderEnabled && eyeTexture)
{
// We need to render to the eyeTexture with the texture viewport.
// Setup rendering to the texture.
ovrGLTexture* eyeTextureGL = const_cast<ovrGLTexture*>(reinterpret_cast<const ovrGLTexture*>(eyeTexture));
OVR_ASSERT(eyeTextureGL->Texture.Header.API == ovrRenderAPI_OpenGL);
// We init a temporary Context, Bind our own context, then Bind the temporary context below before exiting.
// It's more exensive to have a temp context copy made here instead of having it as a saved member variable,
// but we can't have a saved member variable because the app might delete the saved member behind our back
// or associate it with another thread, which would cause our bind of it before exiting to be a bad operation.
Context currentGLContext; // To do: Change this to use the AutoContext class that was recently created.
currentGLContext.InitFromCurrent();
if(GLContext.GetIncarnation() == 0) // If not yet initialized...
GLContext.CreateShared(currentGLContext);
GLContext.Bind();
#if defined(OVR_OS_MAC) // To consider: merge the following into the Bind function.
GLContext.SetSurface(currentGLContext);
#endif
// Load the graphics if not loaded already.
if (!pTexture)
LoadGraphics();
// Calculate ortho projection.
GetOrthoProjection(RenderState, OrthoProjection);
// Set the rendering to be to the eye texture.
glBindFramebuffer(GL_FRAMEBUFFER, FrameBuffer);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, eyeTextureGL->OGL.TexId, 0);
glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, 0); // We aren't using depth, as we currently want this to overwrite everything.
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
OVR_ASSERT(status == GL_FRAMEBUFFER_COMPLETE); OVR_UNUSED(status);
// Set up the viewport
const GLint x = (GLint)eyeTextureGL->Texture.Header.RenderViewport.Pos.x;
const GLint y = (GLint)eyeTextureGL->Texture.Header.RenderViewport.Pos.y; // Note that GL uses bottom-up coordinates.
const GLsizei w = (GLsizei)eyeTextureGL->Texture.Header.RenderViewport.Size.w;
const GLsizei h = (GLsizei)eyeTextureGL->Texture.Header.RenderViewport.Size.h;
glViewport(x, y, w, h);
// Set fixed-function render states.
//glDepthRange(0.0, 1.0); // This is the default
glDepthMask(GL_FALSE);
glDisable(GL_DEPTH_TEST);
glFrontFace(GL_CW);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Enable the buffer and shaders we use.
ShaderFill fill(pShaderSet);
if (pTexture)
fill.SetTexture(0, pTexture);
// Set shader uniforms.
const float scale = HSWDISPLAY_SCALE * ((RenderState.OurHMDInfo.HmdType == HmdType_DK1) ? 0.70f : 1.f);
pShaderSet->SetUniform2f("Scale", scale, scale / 2.f); // X and Y scale. Y is a fixed proportion to X in order to give a certain aspect ratio.
pShaderSet->SetUniform2f("PositionOffset", OrthoProjection[eye].GetTranslation().x, 0.0f);
// Set vertex attributes
if (GLVersionInfo.SupportsVAO)
{
OVR_ASSERT(VAO != 0);
glBindVertexArray(VAO);
}
if(!VAOInitialized) // This executes for the case that VAO isn't supported.
{
glBindBuffer(GL_ARRAY_BUFFER, pVB->GLBuffer); // This must be called before glVertexAttribPointer is called below.
const GLuint shaderProgram = pShaderSet->Prog;
GLint attributeLocationArray[3];
attributeLocationArray[0] = glGetAttribLocation(shaderProgram, "Position");
glVertexAttribPointer(attributeLocationArray[0], sizeof(Vector3f)/sizeof(float), GL_FLOAT, false, sizeof(HASWVertex), reinterpret_cast<char*>(offsetof(HASWVertex, Pos)));
attributeLocationArray[1] = glGetAttribLocation(shaderProgram, "Color");
glVertexAttribPointer(attributeLocationArray[1], sizeof(Color)/sizeof(uint8_t), GL_UNSIGNED_BYTE, true, sizeof(HASWVertex), reinterpret_cast<char*>(offsetof(HASWVertex, C))); // True because we want it to convert [0,255] to [0,1] for us.
attributeLocationArray[2] = glGetAttribLocation(shaderProgram, "TexCoord");
glVertexAttribPointer(attributeLocationArray[2], sizeof(float[2])/sizeof(float), GL_FLOAT, false, sizeof(HASWVertex), reinterpret_cast<char*>(offsetof(HASWVertex, U)));
for (size_t i = 0; i < OVR_ARRAY_COUNT(attributeLocationArray); i++)
glEnableVertexAttribArray((GLuint)i);
}
fill.Set(Prim_TriangleStrip);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
if (GLVersionInfo.SupportsVAO)
{
VAOInitialized = true;
glBindVertexArray(0);
}
currentGLContext.Bind();
}
}
TorusExample(void)
: make_torus(1.0, 0.5, 72, 48)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, projection_matrix(prog, "ProjectionMatrix")
, camera_matrix(prog, "CameraMatrix")
, model_matrix(prog, "ModelMatrix")
{
// Set the vertex shader source and compile it
vs.Source(
"#version 330\n"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec3 Normal;"
"in vec2 TexCoord;"
"out vec3 vertNormal;"
"out vec3 vertLight;"
"out vec2 vertTexCoord;"
"uniform vec3 LightPos;"
"void main(void)"
"{"
" gl_Position = ModelMatrix * Position;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLight = LightPos - gl_Position.xyz;"
" vertTexCoord = TexCoord;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
"}"
).Compile();
// set the fragment shader source and compile it
fs.Source(
"#version 330\n"
"uniform sampler2D TexUnit;"
"in vec3 vertNormal;"
"in vec3 vertLight;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float l = sqrt(length(vertLight));"
" float d = l > 0? dot("
" vertNormal, "
" normalize(vertLight)"
" ) / l : 0.0;"
" float i = 0.2 + 3.2*max(d, 0.0);"
" fragColor = texture(TexUnit, vertTexCoord)*i;"
"}"
).Compile();
// attach the shaders to the program
prog.AttachShader(vs).AttachShader(fs);
// link and use it
prog.Link();
gl.Use(prog);
// bind the VAO for the torus
gl.Bind(torus);
// bind the VBO for the torus vertices
gl.Bind(Buffer::Target::Array, verts);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
// upload the data
gl.Current(Buffer::Target::Array).Data(data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the torus normals
gl.Bind(Buffer::Target::Array, normals);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
// upload the data
gl.Current(Buffer::Target::Array).Data(data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// bind the VBO for the torus texture coordinates
gl.Bind(Buffer::Target::Array, texcoords);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.TexCoordinates(data);
// upload the data
gl.Current(Buffer::Target::Array).Data(data);
// setup the vertex attribs array for the vertices
VertexArrayAttrib attr(prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
// setup the texture
gl.Bind(Texture::Target::_2D, tex);
{
GLuint s = 256;
std::vector<GLubyte> tex_data(s*s);
for(GLuint v=0;v!=s;++v)
{
for(GLuint u=0;u!=s;++u)
{
tex_data[v*s+u] = rand() % 0x100;
}
}
gl.Current(Texture::Target::_2D)
.MinFilter(TextureMinFilter::Linear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::Repeat)
.WrapT(TextureWrap::Repeat)
.SwizzleG(TextureSwizzle::Red)
.SwizzleB(TextureSwizzle::Red)
.Image2D(
0,
PixelDataInternalFormat::Red,
s, s,
0,
PixelDataFormat::Red,
PixelDataType::UnsignedByte,
tex_data.data()
);
}
// typechecked uniform with exact data type
Typechecked<Uniform<SLtoCpp<SLDataType::Sampler2D>>>(prog, "TexUnit").Set(0);
//
Uniform<Vec3f>(prog, "LightPos").Set(4.0f, 4.0f, -8.0f);
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.Enable(Capability::CullFace);
gl.FrontFace(make_torus.FaceWinding());
gl.CullFace(Face::Back);
}
GlassExample(void)
: make_plane(Vec3f(2.0f, 0.0f, 0.0f), Vec3f(0.0f, 0.0f, -2.0f))
, plane_instr(make_plane.Instructions())
, plane_indices(make_plane.Indices())
, make_shape()
, shape_instr(make_shape.Instructions())
, shape_indices(make_shape.Indices())
, plane_vs(ObjectDesc("Plane vertex"))
, shape_vs(ObjectDesc("Shape vertex"))
, plane_fs(ObjectDesc("Plane fragment"))
, shape_fs(ObjectDesc("Shape fragment"))
, plane_proj_matrix(plane_prog)
, plane_camera_matrix(plane_prog)
, plane_model_matrix(plane_prog)
, shape_proj_matrix(shape_prog)
, shape_camera_matrix(shape_prog)
, shape_model_matrix(shape_prog)
, shape_clip_plane(shape_prog)
, shape_clip_direction(shape_prog)
, width(512)
, height(512)
, tex_side(512)
{
plane_vs.Source(
"#version 140\n"
"uniform vec3 LightPosition;"
"uniform mat4 ProjectionMatrix, CameraMatrix, ModelMatrix;"
"in vec4 Position;"
"in vec2 TexCoord;"
"out vec3 vertLightDir;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = "
" ModelMatrix* "
" Position;"
" vertLightDir = normalize("
" LightPosition - gl_Position.xyz"
" );"
" gl_Position = "
" ProjectionMatrix *"
" CameraMatrix *"
" gl_Position;"
" vertTexCoord = TexCoord;"
"}"
);
plane_vs.Compile();
plane_fs.Source(
"#version 140\n"
"uniform vec3 Normal;"
"in vec3 vertLightDir;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"void main(void)"
"{"
" float checker = ("
" int(vertTexCoord.x*18) % 2+"
" int(vertTexCoord.y*18) % 2"
" ) % 2;"
" vec3 color = mix("
" vec3(0.2, 0.4, 0.9),"
" vec3(0.2, 0.2, 0.7),"
" checker"
" );"
" float d = dot("
" Normal, "
" vertLightDir"
" );"
" float intensity = 0.5 + pow(1.4*d, 2.0);"
" fragColor = vec4(color*intensity, 1.0);"
"}"
);
plane_fs.Compile();
plane_prog.AttachShader(plane_vs);
plane_prog.AttachShader(plane_fs);
plane_prog.Link();
plane_prog.Use();
plane_proj_matrix.BindTo("ProjectionMatrix");
plane_camera_matrix.BindTo("CameraMatrix");
plane_model_matrix.BindTo("ModelMatrix");
Vec3f lightPos(3.0f, 3.0f, 3.0f);
Uniform<Vec3f>(plane_prog, "LightPosition").Set(lightPos);
Uniform<Vec3f>(plane_prog, "Normal").Set(make_plane.Normal());
gl.Bind(plane);
gl.Bind(Buffer::Target::Array, plane_verts);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_plane.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(plane_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, plane_texcoords);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_plane.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(plane_prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
shape_vs.Source(
"#version 140\n"
"uniform vec3 LightPosition;"
"uniform mat4 ProjectionMatrix, ModelMatrix, CameraMatrix;"
"uniform vec4 ClipPlane;"
"uniform float ClipDirection;"
"in vec4 Position;"
"in vec3 Normal;"
"out vec3 vertNormal;"
"out vec3 vertLightDir;"
"out vec3 vertLightRefl;"
"out vec3 vertViewDir;"
"out vec2 vertTexCoord;"
"void main(void)"
"{"
" gl_Position = "
" ModelMatrix *"
" Position;"
" gl_ClipDistance[0] = "
" ClipDirection* "
" dot(ClipPlane, gl_Position);"
" vertLightDir = LightPosition - gl_Position.xyz;"
" vertNormal = mat3(ModelMatrix)*Normal;"
" vertLightRefl = reflect("
" -normalize(vertLightDir),"
" normalize(vertNormal)"
" );"
" vertViewDir = (vec4(0.0, 0.0, 1.0, 1.0)*CameraMatrix).xyz;"
" gl_Position = ProjectionMatrix * CameraMatrix * gl_Position;"
" vec3 TexOffs = mat3(CameraMatrix)*vertNormal*0.05;"
" vertTexCoord = "
" vec2(0.5, 0.5) +"
" (gl_Position.xy/gl_Position.w)*0.5 +"
" (TexOffs.z<0.0 ? TexOffs.xy : -TexOffs.xy);"
"}"
);
shape_vs.Compile();
shape_fs.Source(
"#version 140\n"
"uniform sampler2D RefractTex;"
"in vec3 vertNormal;"
"in vec3 vertLightDir;"
"in vec3 vertLightRefl;"
"in vec3 vertViewDir;"
"in vec2 vertTexCoord;"
"out vec4 fragColor;"
"float adj_lt(float i)"
"{"
" return i > 0.0 ? i : -0.7*i;"
"}"
"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 tex = texture(RefractTex, vertTexCoord).rgb;"
" fragColor = vec4("
" tex * 0.5 + "
" (lt + tex) * 1.5 * adj_lt(d) + "
" lt * pow(adj_lt(s), 64), "
" 1.0"
" );"
"}"
);
shape_fs.Compile();
shape_prog.AttachShader(shape_vs);
shape_prog.AttachShader(shape_fs);
shape_prog.Link();
shape_prog.Use();
shape_proj_matrix.BindTo("ProjectionMatrix");
shape_camera_matrix.BindTo("CameraMatrix");
shape_model_matrix.BindTo("ModelMatrix");
shape_clip_plane.BindTo("ClipPlane");
shape_clip_direction.BindTo("ClipDirection");
Uniform<Vec3f>(shape_prog, "LightPosition").Set(lightPos);
gl.Bind(shape);
gl.Bind(Buffer::Target::Array, shape_verts);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(shape_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
gl.Bind(Buffer::Target::Array, shape_normals);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_shape.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(shape_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
//
Texture::Active(0);
UniformSampler(shape_prog, "RefractTex").Set(0);
{
gl.Bound(Texture::Target::_2D, refract_tex)
.MinFilter(TextureMinFilter::Linear)
.MagFilter(TextureMagFilter::Linear)
.WrapS(TextureWrap::MirroredRepeat)
.WrapT(TextureWrap::MirroredRepeat)
.Image2D(
0,
PixelDataInternalFormat::RGB,
tex_side, tex_side,
0,
PixelDataFormat::RGB,
PixelDataType::UnsignedByte,
nullptr
);
}
//
gl.ClearColor(0.8f, 0.8f, 0.7f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
}
TorusExample(void)
: make_torus(1.0, 0.5, 18, 36)
, torus_instr(make_torus.Instructions())
, torus_indices(make_torus.Indices())
, transf_prog(make_transf_prog())
, face_prog(make_face_prog())
, frame_prog(make_frame_prog())
, projection_matrix(transf_prog, "ProjectionMatrix")
, camera_matrix(transf_prog, "CameraMatrix")
, model_matrix(transf_prog, "ModelMatrix")
, transf_time(transf_prog, "Time")
{
transf_prog.Use();
torus.Bind();
verts.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Positions(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(transf_prog, "Position");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
normals.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.Normals(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(transf_prog, "Normal");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
texcoords.Bind(Buffer::Target::Array);
{
std::vector<GLfloat> data;
GLuint n_per_vertex = make_torus.TexCoordinates(data);
Buffer::Data(Buffer::Target::Array, data);
VertexArrayAttrib attr(transf_prog, "TexCoord");
attr.Setup<GLfloat>(n_per_vertex);
attr.Enable();
}
face_pp.Bind();
face_prog.Use();
face_pp.UseStages(transf_prog).Vertex().Geometry();
face_pp.UseStages(face_prog).Fragment();
frame_pp.Bind();
frame_prog.Use();
frame_pp.UseStages(transf_prog).Vertex().Geometry();
frame_pp.UseStages(frame_prog).Fragment();
gl.Bind(NoProgramPipeline());
gl.Use(NoProgram());
gl.ClearColor(0.7f, 0.6f, 0.5f, 0.0f);
gl.ClearDepth(1.0f);
gl.Enable(Capability::DepthTest);
gl.DepthFunc(CompareFn::Less);
gl.FrontFace(make_torus.FaceWinding());
}
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());
}
