msld.C

Go to the documentation of this file.

/*****************************************************************
 * msld.C
 *****************************************************************/
#include "gtex/gl_extensions.H"
#include "msld.H"
#include "gtex/glsl_normal.H"
#include "gtex/ref_image.H"

static bool debug = Config::get_var_bool("DEBUG_MSLD", false);

inline GTexture*
get_normal_shader(Patch* p)
{
   GLSLNormalShader* ret = new GLSLNormalShader(p);

   return ret;
}

/**********************************************************************
 * MSLDStripCB:
 *
 **********************************************************************/

class MSLDStripCB : public GLStripCB {
 public:
   MSLDStripCB() {}

   void set_locs(GLint loc[5])        { 
     pdir1_attrib_loc = loc[0];
     pdir2_attrib_loc = loc[1];
     k1_attrib_loc = loc[2];
     k2_attrib_loc = loc[3];
     dcurv_tensor_attrib_loc = loc[4];
   }

   virtual void faceCB(CBvert* v, CBface*);

 private:

   GLint pdir1_attrib_loc, pdir2_attrib_loc;
   GLint k1_attrib_loc, k2_attrib_loc;
   GLint dcurv_tensor_attrib_loc;
};
 
void
MSLDStripCB::faceCB(CBvert* v, CBface* f)
{
   assert(v && f);

   // Send curvature data as vertex attributes:
   
   Wvec pdir1 = v->pdir1();
   Wvec pdir2 = v->pdir2();

   glVertexAttrib3fARB(pdir1_attrib_loc,
                       static_cast<GLfloat>(pdir1[0]),
                       static_cast<GLfloat>(pdir1[1]),
                       static_cast<GLfloat>(pdir1[2]));
   glVertexAttrib3fARB(pdir2_attrib_loc,
                       static_cast<GLfloat>(pdir2[0]),
                       static_cast<GLfloat>(pdir2[1]),
                       static_cast<GLfloat>(pdir2[2]));
                       
   glVertexAttrib1fARB(k1_attrib_loc, static_cast<GLfloat>(v->k1()));
   glVertexAttrib1fARB(k2_attrib_loc, static_cast<GLfloat>(v->k2()));
   
   double *dcurv = &(v->dcurv_tensor().dcurv[0]);
   
   glVertexAttrib4fARB(dcurv_tensor_attrib_loc,
                       static_cast<GLfloat>(dcurv[0]),
                       static_cast<GLfloat>(dcurv[1]),
                       static_cast<GLfloat>(dcurv[2]),
                       static_cast<GLfloat>(dcurv[3]));

   glNormal3dv(f->vert_normal(v).data());
   glVertex3dv(v->loc().data());

}


/**********************************************************************
 * MSLDShader:
 *
 *  ...
 **********************************************************************/
GLuint          MSLDShader::_program = 0;
bool            MSLDShader::_did_init = false;
//GLint   MSLDShader::_tone_tex_loc(-1);
//GLint   MSLDShader::_width_loc(-1);
//GLint   MSLDShader::_height_loc(-1);

MSLDShader* MSLDShader::_instance(0);

//MSLDShader::MSLDShader(Patch* p) : GLSLShader(p, new MSLDStripCB), 
MSLDShader::MSLDShader(Patch* p) : GLSLShader(p), _tone_shader(0)
{
  if(debug){
    cerr<<"MSLD Debug's working"<<endl;
  }

  set_tone_shader(get_normal_shader(p));
}

MSLDShader::~MSLDShader() 
{
   gtextures().delete_all(); 
}

void
MSLDShader::set_tone_shader(GTexture* g)
{
   if (g == _tone_shader)
      return;
   delete _tone_shader;
   _tone_shader = g;
   changed();
}

MSLDShader* 
MSLDShader::get_instance()
{
   if (!_instance) {
      _instance = new MSLDShader();
      assert(_instance);
   }
   return _instance;
}

bool 
MSLDShader::get_variable_locs()
{
  // get_uniform_loc("toon_tex", _tex_loc);

   // other variables here as needed...
/*   MSLDStripCB* cb = dynamic_cast<MSLDStripCB*>(_cb);
   GLint loc[5];

   loc[0] = glGetAttribLocationARB(_program, "pdir1");
   loc[1] = glGetAttribLocationARB(_program, "pdir2");
   loc[2] = glGetAttribLocationARB(_program, "k1");
   loc[3] = glGetAttribLocationARB(_program, "k2");
   loc[4] = glGetAttribLocationARB(_program, "dcurv_tensor");

   cb->set_locs(loc);
   get_uniform_loc("scthresh", scthresh_uniform_loc);
   get_uniform_loc("feature_size", feature_size_uniform_loc);
*/

   get_uniform_loc("tone_map", _tone_tex_loc);
   get_uniform_loc("width",  _width_loc);
   get_uniform_loc("height", _height_loc);

   return true;
}

bool
MSLDShader::set_uniform_variables() const
{
   // send uniform variable values to the program
   
   if(_patch){
      //tone map variables
      glUniform1i(_tone_tex_loc, TexMemRefImage::lookup_tex_unit() - GL_TEXTURE0);
      glUniform1fARB(_width_loc,  1.0/VIEW::peek()->width());
      glUniform1fARB(_height_loc, 1.0/VIEW::peek()->height());

/*      glUniform1fARB(feature_size_uniform_loc,
                  static_cast<GLfloat>(_patch->mesh()->curvature()->feature_size()));

      glUniform1fARB(scthresh_uniform_loc, 0.01);*/
      return true;
   }

   return false;
}

GTexture_list 
MSLDShader::gtextures() const
{
   return GTexture_list(_tone_shader);
}

void
MSLDShader::set_gl_state(GLbitfield mask) const
{
   GLSLShader::set_gl_state(mask);
   // set the color from the VIEW background color:
   GL_COL(VIEW::peek()->color(), alpha());    // GL_CURRENT_BIT
}

RefImageClient::ref_img_t 
MSLDShader::use_ref_image()
{
   // Tells the caller that we want to use a TexMemRefImage
   return ref_img_t(REF_IMG_TEX_MEM);
}

int 
MSLDShader::draw_tex_mem_ref()
{
   // Draw the reference image for tone.
   return _tone_shader->draw(VIEW::peek());
}
// end of file msld.C

---