demos/forestpond/source/water.cpp

   1 #include <msp/gl/camera.h>
   2 #include <msp/gl/framebuffer.h>
   3 #include <msp/gl/mesh.h>
   4 #include <msp/gl/renderer.h>
   5 #include <msp/strings/format.h>
   6 #include "water.h"
   7
   8 using namespace std;
   9 using namespace Msp;
  10
  11 Water::Water(const GL::Object &o, DataFile::Collection &resources, const Region &region):
  12         ObjectInstance(o),
  13         width((region.right-region.left)*100.0f),
  14         height((region.top-region.bottom)*100.0f),
  15         current(&state[0]),
  16         next(&state[1]),
  17         sampler(resources.get<GL::Sampler>("linear_clip.samp")),
  18         sim_integrate(resources.get<GL::Program>("fluidsim_integrate.glsl.shader")),
  19         sim_velocity(resources.get<GL::Program>("fluidsim_velocity.glsl.shader")),
  20         sim_clamp(resources.get<GL::Program>("fluidsim_clamp.glsl.shader")),
  21         normals_shader(resources.get<GL::Program>("water_normals.glsl.shader")),
  22         variance_x_shader(resources.get<GL::Program>("water_variance_x.glsl.shader")),
  23         variance_y_shader(resources.get<GL::Program>("water_variance_y.glsl.shader"))
  24 {
  25         sim_shdata.set_debug_name("Water sim params");
  26         sim_shdata.uniform("delta_time", stepsize);
  27         sim_shdata.uniform("velocity_damping", 0.99995f);
  28         sim_shdata.uniform("gravity", 981.0f);
  29         sim_shdata.uniform("max_flow_fraction", 0.9999f);
  30         sim_shdata.uniform("residual_depth", 0.01f);
  31
  32         shdata.uniform("Region.scale", 1.0f/(region.right-region.left), 1.0f/(region.top-region.bottom));
  33         shdata.uniform("Region.offset", -region.left/(region.right-region.left), -region.bottom/(region.top-region.bottom));
  34         shdata.uniform("Region.amplitude", 0.01f);
  35
  36         bottom.storage(GL::R32F, width, height, 1);
  37         bottom.set_debug_name("Water bottom");
  38         for(unsigned i=0; i<2; ++i)
  39         {
  40                 state[i].surface.storage(GL::R32F, width, height, 1);
  41                 state[i].surface.set_debug_name(format("Water surface[%d]", i));
  42                 state[i].velocity.storage(GL::RG32F, width, height, 1);
  43                 state[i].velocity.set_debug_name(format("Water velocity[%d]", i));
  44                 state[i].clamping.storage(GL::R32F, width, height, 1);
  45                 state[i].clamping.set_debug_name(format("Water clamping[%d]", i));
  46         }
  47
  48         normals.storage(GL::RG8, width, height, 1);
  49         normals.set_debug_name("Water normals");
  50
  51         variance_x.storage(GL::R16F, width, height, 1);
  52         variance_x.set_debug_name("Water variance X");
  53         variance_y.storage(GL::R16F, width, height, 1);
  54         variance_y.set_debug_name("Water variance Y");
  55
  56         GL::Framebuffer bottom_fbo((GL::COLOR_ATTACHMENT,GL::R32F));
  57         bottom_fbo.attach(GL::COLOR_ATTACHMENT, bottom);
  58
  59         GL::Camera bottom_camera;
  60         bottom_camera.set_orthographic(region.right-region.left, region.top-region.bottom);
  61         bottom_camera.set_position(GL::Vector3((region.left+region.right)/2, (region.bottom+region.top)/2, 0.0f));
  62         bottom_camera.set_depth_clip(-10.0f, 10.0f);
  63
  64         const GL::Program &bottom_shprog = resources.get<GL::Program>("fluidsim_bottom.glsl.shader");
  65         const GL::Program &fill_shprog = resources.get<GL::Program>("fluidsim_fill.glsl.shader");
  66
  67         GL::Renderer renderer;
  68         renderer.begin();
  69         renderer.set_camera(bottom_camera);
  70         renderer.set_framebuffer(&bottom_fbo);
  71         renderer.set_shader_program(&bottom_shprog);
  72         region.terrain.draw(renderer);
  73
  74         renderer.set_shader_program(&fill_shprog);
  75         renderer.set_texture("bottom", &bottom, &sampler);
  76         for(unsigned i=0; i<2; ++i)
  77         {
  78                 renderer.set_storage_texture("surface_out", &state[i].surface);
  79                 renderer.set_storage_texture("velocity_out", &state[i].velocity);
  80                 renderer.set_storage_texture("clamping_out", &state[i].clamping);
  81                 renderer.dispatch((width+7)/8, (height+7)/8);
  82         }
  83         renderer.end();
  84 }
  85
  86 void Water::setup_frame(GL::Renderer &renderer)
  87 {
  88         if(simulated)
  89                 return;
  90
  91         GL::Renderer::Push _push(renderer);
  92
  93         unsigned groups_x = (width+5)/8;
  94         unsigned groups_y = (height+5)/8;
  95
  96         int drop_x = rng()%width;
  97         int drop_y = rng()%height;
  98         sim_shdata.uniform("drop_pos", drop_x, drop_y);
  99         sim_shdata.uniform("drop_time", time);
 100
 101         renderer.add_shader_data(sim_shdata);
 102         renderer.set_texture("bottom_in", &bottom, &sampler);
 103         for(unsigned i=0; i<16; ++i)
 104         {
 105                 sim_shdata.uniform("time", time);
 106
 107                 renderer.set_shader_program(&sim_integrate);
 108                 renderer.set_storage_texture("surface_out", &next->surface);
 109                 renderer.set_storage_texture("velocity_out", &next->velocity);
 110                 renderer.set_storage_texture("clamping_out", &next->clamping);
 111                 renderer.set_texture("surface_in", &current->surface, &sampler);
 112                 renderer.set_texture("velocity_in", &current->velocity, &sampler);
 113                 renderer.set_texture("clamping_in", &current->clamping, &sampler);
 114                 renderer.dispatch(groups_x, groups_y);
 115
 116                 renderer.set_shader_program(&sim_velocity);
 117                 renderer.set_texture("surface_in", &next->surface, &sampler);
 118                 renderer.dispatch(groups_x, groups_y);
 119
 120                 renderer.set_shader_program(&sim_clamp);
 121                 renderer.set_texture("velocity_in", &next->velocity, &sampler);
 122                 renderer.dispatch(groups_x, groups_y);
 123
 124                 time += stepsize;
 125                 swap(current, next);
 126         }
 127
 128         renderer.set_shader_program(&normals_shader);
 129         renderer.set_texture("surface_in", &current->surface, &sampler);
 130         renderer.set_storage_texture("normals_out", &normals);
 131         renderer.dispatch(groups_x, groups_y);
 132
 133         renderer.set_shader_program(&variance_x_shader);
 134         renderer.set_texture("normals_in", &normals, &sampler);
 135         renderer.set_storage_texture("variance_out", &variance_x);
 136         renderer.dispatch((width-1)/8, groups_y);
 137
 138         renderer.set_shader_program(&variance_y_shader);
 139         renderer.set_texture("variance_in", &variance_x, &sampler);
 140         renderer.set_storage_texture("variance_out", &variance_y);
 141         renderer.dispatch(groups_x, (height-1)/8);
 142
 143         simulated = true;
 144 }
 145
 146 void Water::finish_frame()
 147 {
 148         simulated = false;
 149 }
 150
 151 void Water::setup_render(GL::Renderer &renderer, GL::Tag tag) const
 152 {
 153         ObjectInstance::setup_render(renderer, tag);
 154         renderer.add_shader_data(shdata);
 155         renderer.set_texture("bottom", &bottom, &sampler);
 156         renderer.set_texture("surface", &current->surface, &sampler);
 157         renderer.set_texture("normals", &normals, &sampler);
 158         renderer.set_texture("variance", &variance_y, &sampler);
 159 }