/home/hauberg/Dokumenter/Capture/humim-tracker-0.1/src/OpenTissue/OpenTissue/utility/volume_rendering/slabbing_shader/volume_rendering_slabbing_shader.h

Go to the documentation of this file.

#ifndef OPENTISSUE_UTILITY_VOLUME_RENDERING_SLABBING_VOLUME_RENDERING_SHADER_SLABBING_SHADER_H
#define OPENTISSUE_UTILITY_VOLUME_RENDERING_SLABBING_VOLUME_RENDERING_SHADER_SLABBING_SHADER_H
//
// OpenTissue Template Library
// - A generic toolbox for physics-based modeling and simulation.
// Copyright (C) 2008 Department of Computer Science, University of Copenhagen.
//
// OTTL is licensed under zlib: http://opensource.org/licenses/zlib-license.php
//
#include <OpenTissue/configuration.h>

#include <OpenTissue/gpu/cg/cg_program.h>
#include <OpenTissue/core/geometry/geometry_obb_z_slicer.h>
#include <OpenTissue/utility/volume_rendering/volume_rendering_volume_shader.h>

#include <string>

namespace OpenTissue
{
  namespace volume_rendering
  {

    template<typename math_types>
    class SlabbingShader 
      : public VolumeShader< SlabbingShader<math_types> >
    {
    public:

      typedef typename math_types::real_type      real_type;
      typedef typename math_types::vector3_type   vector3_type;

    protected:

      cg::Program    m_vertex_program;
      cg::Program    m_fragment_program;
      unsigned int m_slice_cnt;         
      GLfloat      m_eye2model_matrix[16];

    public:

      SlabbingShader()
        : m_vertex_program()
        , m_fragment_program()
        , m_slice_cnt(64)
      {
      }

    public:

      void init(){};

      bool front2back()const{ return false; }

      template<typename texture2d_pointer>
      void pre_render ( texture2d_pointer & color_table )
      {
        glPushAttrib( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_ENABLE_BIT );

        //--- Setup openGL state
        glEnable( GL_BLEND );
        glBlendFunc( GL_ONE, GL_ONE_MINUS_SRC_ALPHA );
        glDisable( GL_LIGHTING );
        glDisable( GL_DEPTH_TEST );
        glEnable( GL_ALPHA_TEST );
        glAlphaFunc(GL_GREATER, 0.01 );//--- hmmm, maybe this should be a controllable user parameter?

        GLfloat model2eye_matrix[16];
        glGetFloatv( GL_MODELVIEW_MATRIX, model2eye_matrix );      
        gl::invert( model2eye_matrix, m_eye2model_matrix );

        //--- setup Cg
        static std::string path = opentissue_path + "/OpenTissue/utility/volume_rendering/slabbing_shader/";

        if(!m_vertex_program.is_program_loaded())
          m_vertex_program.load_from_file(cg::Program::vertex_program,path + "/vp.cg");

        m_vertex_program.set_modelview_projection_matrix();
        m_vertex_program.set_modelview_inverse_matrix();
        m_vertex_program.enable();

        //--- load fragment program
        if(!m_fragment_program.is_program_loaded())
          m_fragment_program.load_from_file(cg::Program::fragment_program,path + "/fp.cg");

        m_fragment_program.set_input_texture( "color_table"  ,  color_table );
        m_fragment_program.enable();
      }

      template<typename tile_type>
      void render(tile_type const & tile)
      {
        using std::fabs;

        static vector3_type slice[8];
        real_type slab_width = fabs(tile.m_min_depth - tile.m_max_depth)/(m_slice_cnt-1);
        m_fragment_program.set_input_texture( "volume" ,  tile.m_volume_texture );
        for ( unsigned int s = 0; s < m_slice_cnt; ++s )
        {
          real_type t = (1.0 + s) / (1.0 + m_slice_cnt);
          real_type depth = (tile.m_max_depth-tile.m_min_depth)*t + tile.m_min_depth;
          unsigned int slice_size = OpenTissue::geometry::obb_z_slice(tile.m_eye_vertices,depth,slice);
          glBegin( GL_TRIANGLE_FAN );
          for ( unsigned int i = 0; i < slice_size; ++i )
          {
            slice[i] = gl::xform( m_eye2model_matrix, slice[i]);
            glMultiTexCoord1f(GL_TEXTURE0, slab_width                                                  );
            glMultiTexCoord3f(GL_TEXTURE1, tile.m_tile_min_x, tile.m_tile_min_y,  tile.m_tile_min_z );
            glMultiTexCoord3f(GL_TEXTURE2, tile.m_tile_width, tile.m_tile_height, tile.m_tile_depth );
            glVertex3f(   slice[ i ][ 0 ],  slice[ i ][ 1 ],  slice[ i ][ 2 ] );
          }
          glEnd();
        }
      }

      void post_render()
      {
        m_fragment_program.disable();
        m_vertex_program.disable();
        glPopAttrib( );
      }
    };

  } // namespace volume_rendering
} // namespace OpenTissue

// OPENTISSUE_UTILITY_VOLUME_RENDERING_SLABBING_VOLUME_RENDERING_SHADER_SLABBING_SHADER_H
#endif