X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Fshadowmap.cpp;h=921a1747875b4bf0b349042dac6aab26095cff84;hp=bedfcfd51c0f1e2aa4d1f5bd374e1c5b8a342620;hb=99d25b5ef615a23ef63645fea87596b3384b5ede;hpb=3663bed18358a2399b2a8a8f7779d85e0ed81bd0 diff --git a/source/shadowmap.cpp b/source/shadowmap.cpp index bedfcfd5..921a1747 100644 --- a/source/shadowmap.cpp +++ b/source/shadowmap.cpp @@ -1,39 +1,34 @@ -/* $Id$ - -This file is part of libmspgl -Copyright © 2009 Mikko Rasa, Mikkosoft Productions -Distributed under the LGPL -*/ - #include #include +#include "camera.h" #include "light.h" -#include "matrix.h" -#include "misc.h" -#include "projection.h" +#include "renderer.h" #include "scene.h" #include "shadowmap.h" -#include "texunit.h" +#include "tests.h" using namespace std; namespace Msp { namespace GL { -ShadowMap::ShadowMap(unsigned s, const Scene &c, const Light &l): +ShadowMap::ShadowMap(unsigned s, Renderable &r, const Light &l): + Effect(r), size(s), - scene(c), light(l), - unit(3), - radius(1) + radius(1), + depth_bias(4), + rendered(false) { depth_buf.set_min_filter(LINEAR); depth_buf.set_compare_enabled(true); depth_buf.set_compare_func(LEQUAL); depth_buf.set_wrap(CLAMP_TO_EDGE); - depth_buf.storage(DEPTH_COMPONENT, size, size, 0); - depth_buf.image(0, DEPTH_COMPONENT, UNSIGNED_BYTE, 0); + depth_buf.storage(DEPTH_COMPONENT, size, size, 1); fbo.attach(DEPTH_ATTACHMENT, depth_buf, 0); + fbo.require_complete(); + + set_darkness(0.7); } void ShadowMap::set_target(const Vector3 &t, float r) @@ -42,105 +37,81 @@ void ShadowMap::set_target(const Vector3 &t, float r) radius = r; } -void ShadowMap::set_texture_unit(unsigned u) +void ShadowMap::set_darkness(float d) { - unit = u; + if(d<0.0f || d>1.0f) + throw invalid_argument("ShadowMap::set_darkness"); + + shdata.uniform("shadow_darkness", d); } -void ShadowMap::prepare() +void ShadowMap::set_depth_bias(float b) { - Vector4 lpos = light.get_position(); - if(lpos.w) - { - /* XXX Not really proper way to support positional lights, but good - enough when the light source is far away */ - lpos.x -= target.x; - lpos.y -= target.y; - lpos.z -= target.z; - float d = sqrt(lpos.x*lpos.x+lpos.y*lpos.y+lpos.z*lpos.z); - lpos.x /= d; - lpos.y /= d; - lpos.z /= d; - } - - float matrix[16]; - if(abs(lpos.z)>=abs(lpos.x) && abs(lpos.z)>=abs(lpos.y)) - { - float d = sqrt(lpos.x*lpos.x+lpos.z*lpos.z); - matrix[0] = lpos.z/d; - matrix[4] = 0; - matrix[8] = -lpos.x/d; - matrix[1] = -lpos.x*lpos.y/d; - matrix[5] = d; - matrix[9] = -lpos.z*lpos.y/d; - } - else - { - float d = sqrt(lpos.x*lpos.x+lpos.y*lpos.y); - matrix[0] = -lpos.y/d; - matrix[4] = lpos.x/d; - matrix[8] = 0; - matrix[1] = -lpos.x*lpos.z/d; - matrix[5] = -lpos.y*lpos.z/d; - matrix[9] = d; - } - - matrix[2] = lpos.x; - matrix[6] = lpos.y; - matrix[10] = lpos.z; - - matrix[12] = -(target.x*matrix[0]+target.y*matrix[4]+target.z*matrix[8]); - matrix[13] = -(target.x*matrix[1]+target.y*matrix[5]+target.z*matrix[9]); - matrix[14] = -(target.x*matrix[2]+target.y*matrix[6]+target.z*matrix[10]); - matrix[3] = 0; - matrix[7] = 0; - matrix[11] = 0; - matrix[15] = 1; - - { - matrix_mode(PROJECTION); - push_matrix(); - load_identity(); - ortho(-radius, radius, -radius, radius, -radius, radius); - matrix_mode(MODELVIEW); - push_matrix(); - load_matrix(matrix); - - Bind bind_fbo(fbo, true); - fbo.clear(DEPTH_BUFFER_BIT); - scene.render("shadow"); - - matrix_mode(PROJECTION); - pop_matrix(); - matrix_mode(MODELVIEW); - pop_matrix(); - } - - depth_buf.bind_to(unit); - float diam = radius*2; - float s_eq[4] = { matrix[0]/diam, matrix[4]/diam, matrix[8]/diam, matrix[12]/diam+0.5 }; - float t_eq[4] = { matrix[1]/diam, matrix[5]/diam, matrix[9]/diam, matrix[13]/diam+0.5 }; - float r_eq[4] = { -matrix[2]/diam, -matrix[6]/diam, -matrix[10]/diam, 0.5-matrix[14]/diam-4.0/size }; - glTexGeni(GL_S, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); - glTexGenfv(GL_S, GL_EYE_PLANE, s_eq); - enable(GL_TEXTURE_GEN_S); - glTexGeni(GL_T, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); - glTexGenfv(GL_T, GL_EYE_PLANE, t_eq); - enable(GL_TEXTURE_GEN_T); - glTexGeni(GL_R, GL_TEXTURE_GEN_MODE, GL_EYE_LINEAR); - glTexGenfv(GL_R, GL_EYE_PLANE, r_eq); - enable(GL_TEXTURE_GEN_R); - - TexUnit::activate(0); + if(b<0.0f) + throw invalid_argument("ShadowMap::set_depth_bias"); + + depth_bias = b; +} + +void ShadowMap::setup_frame(Renderer &renderer) +{ + if(rendered) + return; + + rendered = true; + renderable.setup_frame(renderer); + + Camera camera; + camera.set_object_matrix(*light.get_matrix()); + camera.set_position(target); + // TODO support point and spot lights with a frustum projection. + // Omnidirectional lights also need a cube shadow map. + camera.set_orthographic(radius*2, radius*2); + camera.set_depth_clip(-radius, radius); + + shadow_matrix = camera.get_object_matrix(); + shadow_matrix.scale(radius*2, radius*2, -radius*2); + shadow_matrix.translate(-0.5, -0.5, depth_bias/size-0.5); + shadow_matrix.invert(); + + BindRestore bind_fbo(fbo); + Bind bind_depth(DepthTest::lequal()); + fbo.clear(DEPTH_BUFFER_BIT); + + Renderer::Push push(renderer); + renderer.set_camera(camera); + + renderer.render(renderable, "shadow"); +} + +void ShadowMap::finish_frame() +{ + renderable.finish_frame(); + rendered = false; } -void ShadowMap::cleanup() +void ShadowMap::render(Renderer &renderer, const Tag &tag) const { - Texture::unbind_from(unit); - disable(GL_TEXTURE_GEN_S); - disable(GL_TEXTURE_GEN_T); - disable(GL_TEXTURE_GEN_R); - TexUnit::activate(0); + if(!enabled_passes.count(tag)) + return renderer.render(renderable, tag); + + Renderer::Push _push_rend(renderer); + + unsigned unit = renderer.allocate_effect_texunit(); + int iunit = unit; + shdata.uniform("shadow", iunit); + + Bind _bind_depth(depth_buf, unit); + + if(const Camera *camera = renderer.get_camera()) + /* Multiply by camera's object matrix to form a matrix that transforms + from eye space to shadow space. */ + shdata.uniform("shd_eye_matrix", shadow_matrix*camera->get_object_matrix()); + else + shdata.uniform("shd_eye_matrix", shadow_matrix); + + renderer.add_shader_data(shdata); + renderer.render(renderable, tag); } } // namespace GL