X-Git-Url: http://git.tdb.fi/?p=libs%2Fgl.git;a=blobdiff_plain;f=source%2Feffects%2Fshadowmap.cpp;h=27b695443341c860337242d5c2908d0479b502d7;hp=a6d431bc200da86e025dcc2b640aa9d2a342d0e0;hb=083a8227715fa32c841fc2b8126e4ab8d2840ba0;hpb=1863f17c5c5563be8492d7f01e5c613a740ea1e9 diff --git a/source/effects/shadowmap.cpp b/source/effects/shadowmap.cpp index a6d431bc..27b69544 100644 --- a/source/effects/shadowmap.cpp +++ b/source/effects/shadowmap.cpp @@ -1,49 +1,156 @@ -#include -#include -#include "camera.h" -#include "light.h" +#include +#include "directionallight.h" +#include "error.h" +#include "lighting.h" +#include "pointlight.h" #include "renderer.h" #include "resources.h" -#include "scene.h" #include "shadowmap.h" -#include "tests.h" using namespace std; namespace Msp { namespace GL { -ShadowMap::ShadowMap(unsigned s, Renderable &r, const Light &l, Renderable &c): +ShadowMap::ShadowMap(unsigned w, unsigned h, Renderable &r, const Lighting *l): Effect(r), - light(l), - shadow_caster(c), + width(w), + height(h), + lighting(l), sampler(Resources::get_global().get("_linear_clamp_shadow.samp")) { - init(s); + depth_buf.storage(DEPTH_COMPONENT32F, width, height, 1); + fbo.set_format((DEPTH_ATTACHMENT,DEPTH_COMPONENT32F)); + fbo.attach(DEPTH_ATTACHMENT, depth_buf, 0); + + set_darkness(1.0f); + for(unsigned i=0; i<4; ++i) + { + string base = format("shadows[%d]", i); + shdata.uniform(base+".type", 0); + shdata.uniform(base+".darkness", 1.0f); + shdata.uniform(base+".matrix_index", 0); + shdata.uniform(base+".region", Vector4(0.0f, 0.0f, 1.0f, 1.0f)); + shdata.uniform(base+".bias", 0.0f, 1.0f); + } + + Matrix dummy_matrix; + shdata.uniform_array("shd_world_matrix", 1, &dummy_matrix); } -ShadowMap::ShadowMap(unsigned s, Renderable &r, const Light &l): - Effect(r), - light(l), - shadow_caster(r), - sampler(Resources::get_global().get("_linear_clamp_shadow.samp")) +ShadowMap::ShadowMap(unsigned s, Renderable &r, const DirectionalLight &l, Renderable &c): + ShadowMap(s, s, r, 0) +{ + add_light(l, s, c); +} + +ShadowMap::ShadowMap(unsigned w, unsigned h, Renderable &r, const Lighting &l): + ShadowMap(w, h, r, &l) +{ } + +void ShadowMap::add_light(const DirectionalLight &light, unsigned s, Renderable &c) { - init(s); + add_light(light, s, DIRECTIONAL, c); } -void ShadowMap::init(unsigned s) +void ShadowMap::add_light(const PointLight &light, unsigned s, Renderable &c) { - size = s; - radius = 1; - depth_bias = 4; - rendered = false; + add_light(light, s, TETRAHEDRON, c); +} - depth_buf.storage(DEPTH_COMPONENT32F, size, size, 1); - fbo.attach(DEPTH_ATTACHMENT, depth_buf, 0); - fbo.require_complete(); +void ShadowMap::add_light(const Light &light, unsigned s, ShadowType type, Renderable &c) +{ + if(!lighting && !lights.empty()) + throw invalid_operation("ShadowMap::add_light"); - set_darkness(1.0f); - shdata.uniform("shd_world_matrix", Matrix()); + int index = (lighting ? lighting->find_light_index(light) : 0); + if(index<0) + throw invalid_argument("ShadowMap::add_light"); + + Rect region(0, 0, s, s); + while(1) + { + int next_bottom = height; + int next_left = region.left; + + int top = region.bottom+region.height; + int right = region.left+region.width; + for(const ShadowedLight &l: lights) + { + int l_top = l.region.bottom+l.region.height; + int l_right = l.region.left+l.region.width; + if(l_top>region.bottom) + next_bottom = min(next_bottom, l_top); + + if(top>l.region.bottom && region.bottoml.region.left && region.leftwidth) + { + if(next_bottom+region.height>height) + throw invalid_operation("ShadowMap::add_light"); + region.bottom = next_bottom; + region.left = 0; + } + else + region.left = next_left; + } + + unsigned n_views = (type==TETRAHEDRON ? 4 : 1); + + lights.emplace_back(); + ShadowedLight &sl = lights.back(); + sl.light = &light; + sl.index = index; + sl.region = region; + sl.type = type; + sl.view_index = views.size(); + sl.shadow_caster = &c; + + views.resize(views.size()+n_views); + for(unsigned i=0; i0) + view.face_matrix = Matrix().rotate(Geometry::Angle::from_turns((i-0.5f)/3.0f), Vector3(0, 0, 1)) + .rotate(Geometry::Angle::straight()-Geometry::acos(1.0f/3.0f), Vector3(1, 0, 0)); + + float triangle_h = sqrt(0.75f)*2.0f; + float bottom = 0.5f/sqrt(0.75f); + float distance = (sqrt(2.0f/3.0f)-sqrt(3.0f/8.0f))*2.0f; + view.camera.set_field_of_view(Geometry::atan(triangle_h/distance)*2.0f); + view.camera.set_aspect_ratio(1.0f/triangle_h); + view.camera.set_frustum_axis(0.0f, 1.0f-bottom/triangle_h); + view.camera.set_frustum_rotation(-Geometry::Angle::from_turns(i/4.0f)); + } + } + + string base = format("shadows[%d]", index); + shdata.uniform(base+".type", static_cast(type)); + shdata.uniform(base+".darkness", darkness); + shdata.uniform(base+".matrix_index", static_cast(sl.view_index)); + + float xf = static_cast(region.left)/width; + float yf = static_cast(region.bottom)/height; + float wf = static_cast(region.width)/width; + float hf = static_cast(region.height)/height; + shdata.uniform(base+".region", Vector4(xf, yf, wf, hf)); + +#ifdef DEBUG + if(!debug_name.empty()) + { + for(unsigned i=sl.view_index; i1.0f) throw invalid_argument("ShadowMap::set_darkness"); - shdata.uniform("shadow_darkness", d); + darkness = d; + for(const ShadowedLight &l: lights) + shdata.uniform(format("shadows[%d].darkness", l.index), d); } void ShadowMap::set_depth_bias(float b) @@ -75,30 +184,59 @@ void ShadowMap::setup_frame(Renderer &renderer) rendered = true; renderable.setup_frame(renderer); - shadow_caster.setup_frame(renderer); + for(const ShadowedLight &l: lights) + l.shadow_caster->setup_frame(renderer); + + for(const ShadowedLight &l: lights) + { + string base = format("shadows[%d]", l.index); + if(l.type==DIRECTIONAL) + shdata.uniform(base+".bias", depth_bias/l.region.width, 0.0f); + else if(l.type==TETRAHEDRON) + { + float distance = (sqrt(2.0f/3.0f)-sqrt(3.0f/8.0f))*2.0f; + float bias = depth_bias*2.0f/(distance*l.region.width); + shdata.uniform(base+".bias", -1001.0f/999.0f, 1.0f-bias); + } + } - shadow_camera.set_object_matrix(*light.get_matrix()); - shadow_camera.set_position(target); - // TODO support point and spot lights with a frustum projection. - // Omnidirectional lights also need a cube shadow map. - shadow_camera.set_orthographic(radius*2, radius*2); - shadow_camera.set_depth_clip(-radius, radius); + vector shadow_matrices; + shadow_matrices.reserve(views.size()); + for(ShadowView &v: views) + { + const ShadowedLight &light = lights[v.light_index]; - shadow_matrix = shadow_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(); + if(light.type==DIRECTIONAL) + { + v.camera.set_object_matrix(*light.light->get_matrix()); + v.camera.set_position(target); + v.camera.set_orthographic(radius*2, radius*2); + v.camera.set_depth_clip(-radius, radius); + } + else if(light.type==TETRAHEDRON) + { + v.camera.set_object_matrix((*light.light->get_matrix())*v.face_matrix); + v.camera.set_depth_clip(radius/1000.0f, radius); + } - shdata.uniform("shd_world_matrix", shadow_matrix); + Matrix to_texcoord = Matrix().translate(Vector3(0.5f, 0.5f, 0.5f)).scale(0.5f); + shadow_matrices.push_back(to_texcoord*v.camera.get_projection_matrix()*v.camera.get_view_matrix()); + } - BindRestore bind_fbo(fbo); - Bind bind_depth(DepthTest::lequal()); - fbo.clear(DEPTH_BUFFER_BIT); + shdata.uniform_array("shd_world_matrix", shadow_matrices.size(), shadow_matrices.data()); - Renderer::Push push(renderer); - renderer.set_camera(shadow_camera); + for(const ShadowView &v: views) + { + const ShadowedLight &light = lights[v.light_index]; - renderer.render(shadow_caster); + Renderer::Push push(renderer); + renderer.set_framebuffer(&fbo); + renderer.set_viewport(&light.region); + renderer.set_scissor(&light.region); + renderer.set_camera(v.camera); + + renderer.render(*light.shadow_caster, (v.face>0 ? "noclear" : "")); + } } void ShadowMap::finish_frame() @@ -112,7 +250,7 @@ void ShadowMap::finish_frame() void ShadowMap::render(Renderer &renderer, Tag tag) const { - if(!enabled_passes.count(tag)) + if(!enabled_methods.count(tag)) return renderer.render(renderable, tag); Renderer::Push _push_rend(renderer); @@ -122,17 +260,102 @@ void ShadowMap::render(Renderer &renderer, Tag tag) const renderer.render(renderable, tag); } -void ShadowMap::set_debug_name(const std::string &name) +void ShadowMap::set_debug_name(const string &name) { #ifdef DEBUG fbo.set_debug_name(name+" [FBO]"); - shadow_camera.set_debug_name(name+".camera"); - depth_buf.set_debug_name(name+"/depth.tex2d"); + for(unsigned i=0; i &renderables) const +{ + Renderable *content = get_item(renderables, content_name); + if(!content || !lighting) + throw invalid_operation("ShadowMap::Template::create"); + + RefPtr shadow_map = new ShadowMap(width, height, *content, *lighting); + shadow_map->set_target(target, radius); + shadow_map->set_depth_bias(depth_bias); + shadow_map->set_darkness(darkness); + + for(const ShadowedLight &l: lights) + { + Renderable *shadow_caster = get_item(renderables, l.shadow_caster_name); + if(!l.light || !shadow_caster) + throw invalid_operation("ShadowMap::Template::create"); + if(const DirectionalLight *dir_light = dynamic_cast(l.light)) + shadow_map->add_light(*dir_light, l.size, *shadow_caster); + else if(const PointLight *point_light = dynamic_cast(l.light)) + shadow_map->add_light(*point_light, l.size, *shadow_caster); + else + throw invalid_operation("ShadowMap::Template::create"); + } + + return shadow_map.release(); +} + + +DataFile::Loader::ActionMap ShadowMap::Template::Loader::shared_actions; + +ShadowMap::Template::Loader::Loader(Template &t, Collection &c): + DerivedObjectLoader(t, c) +{ + set_actions(shared_actions); +} + +void ShadowMap::Template::Loader::init_actions() +{ + Effect::Template::Loader::init_actions(); + add("darkness", &Template::darkness); + add("depth_bias", &Template::depth_bias); + add("light", &Loader::light); + add("lighting", &Template::lighting); + add("radius", &Template::radius); + add("size", &Loader::size_square); + add("size", &Template::width, &Template::height); + add("target", &Loader::target); +} + +void ShadowMap::Template::Loader::light(const string &name) +{ + ShadowedLight light; + light.light = &get_collection().get(name); + load_sub(light); + obj.lights.push_back(light); +} + +void ShadowMap::Template::Loader::size_square(unsigned s) +{ + obj.width = s; + obj.height = s; +} + +void ShadowMap::Template::Loader::target(float x, float y, float z) +{ + obj.target = Vector3(x, y, z); +} + + +DataFile::Loader::ActionMap ShadowMap::Template::ShadowedLight::Loader::shared_actions; + +ShadowMap::Template::ShadowedLight::Loader::Loader(ShadowedLight &l): + ObjectLoader(l) +{ + set_actions(shared_actions); +} + +void ShadowMap::Template::ShadowedLight::Loader::init_actions() +{ + add("size", &ShadowedLight::size); + add("shadow_caster", &ShadowedLight::shadow_caster_name); +} + } // namespace GL } // namespace Msp