basic_texture.C

Go to the documentation of this file.

/**********************************************************************
 * basic_texture.C
 **********************************************************************/
#include "geom/texturegl.H"
#include "mesh/ioblock.H"
#include "mesh/lmesh.H"
#include "std/config.H"

#include "basic_texture.H"
#include "color_id_texture.H"
#include "control_line.H"
#include "creases_texture.H"
#include "curvature_texture.H"
#include "line_drawing.H"
#include "fader_texture.H"
#include "flat_shade.H"
#include "hidden_line.H"
#include "key_line.H"
#include "normals_texture.H"
#include "ref_image.H"
#include "sil_frame.H"
#include "smooth_shade.H"
#include "solid_color.H"
#include "tri_strips_texture.H"
#include "wireframe.H"
#include "zxsil_frame.H"
#include "toon_texture_1D.H"
#include "glsl_shader.H"
#include "halftone_shader.H"
#include "halftone_shader_ex.H"
#include "glsl_xtoon.H"
#include "glsl_toon.H"
#include "glsl_halo.H"
#include "glsl_toon_halo.H"
#include "dots.H"
#include "dots_ex.H"
#include "glsl_hatching.H"
#include "glsl_marble.H"
#include "msld.H"

// make sure textures can be looked up via DECODER mechanism
class DecoderAdds {
 public:
  DecoderAdds() {
    DECODER_ADD(ColorIDTexture);
    DECODER_ADD(ControlFrameTexture);
    DECODER_ADD(ControlLineTexture);
    DECODER_ADD(CreasesTexture);
    DECODER_ADD(CurvatureTexture);
    DECODER_ADD(FlatShadeTexture);
    DECODER_ADD(HiddenLineTexture);
    DECODER_ADD(KeyLineTexture);
    DECODER_ADD(LineDrawingTexture);
    DECODER_ADD(NormalsTexture);
    DECODER_ADD(SilFrameTexture);
    DECODER_ADD(SmoothShadeTexture);
    DECODER_ADD(SolidColorTexture);
    DECODER_ADD(TriStripsTexture);
    DECODER_ADD(VertColorTexture);
    DECODER_ADD(WireframeTexture);
    DECODER_ADD(ZcrossFrameTexture);   
    DECODER_ADD(ToonTexture_1D);
    DECODER_ADD(GLSLShader);
    DECODER_ADD(GLSLLightingShader);
    DECODER_ADD(HalftoneShader);
   DECODER_ADD(HalftoneShaderEx);
    DECODER_ADD(GLSLXToonShader);
    DECODER_ADD(GLSLToonShader);
   DECODER_ADD(GLSLHaloShader);
   DECODER_ADD(GLSLToonShaderHalo);
    DECODER_ADD(DotsShader);
   DECODER_ADD(DotsShader_EX);
    DECODER_ADD(GLSLHatching);
   DECODER_ADD(GLSLMarbleShader);
   DECODER_ADD(MSLDShader);
  }
} DecoderAdds_static;

class SetupGL {
 public:
   SetupGL() {

      // Use VisRefImage's for visibility reference images
      VisRefImage::init();
   }
} SetupGL_static;

// XXX casey 3/18
// XXX enable stencilling; disable all else; just draw to stencil buffer

int OGLTexture::draw_stencil() {
   
   if (_patch == NULL) return -1;
   // push/pop attribs instead
   glColorMask(0, 0, 0, 0);
   glDisable(GL_DEPTH_TEST);
   //glStencilFunc(GL_ALWAYS, _patch->stencil_id(), 0xFF); 
   glStencilFunc(GL_ALWAYS, 1, 0xFF);
   glStencilOp(GL_KEEP, GL_KEEP, GL_INCR);
   //glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
   // just need the simplest kind- just uses GlVertex()
   GLStripCB cb; 
   _patch->draw_tri_strips(&cb);
   
   glColorMask(1, 1, 1, 1);
   glEnable(GL_DEPTH_TEST);
   
   return 1;
}

bool
OGLTexture::set_face_culling() const 
{
   // affects GL_ENABLE_BIT

   static bool no_cull = Config::get_var_bool("JOT_NO_FACE_CULLING",false);

   // If it's not VERBOTEN, and there's a reason to cull, then do:
   BMESH* m = get_cur_mesh(mesh());
   bool ret = (!no_cull && m && m->is_closed_surface());
   if (ret) glEnable (GL_CULL_FACE);        
   else     glDisable(GL_CULL_FACE);
   return ret;
}

int  
OGLTexture::draw_vis_ref() 
{
   // draw for visibility
   GTexture *tex = _patch->get_tex(ColorIDTexture::static_name());

   // Draw simple, filled ID-colored triangles.
   // Some derived GTextures like Wireframe should override this and
   // draw wireframe ID-colored triangles (e.g.).
   return tex ? tex->draw(VIEW::peek()) : 0;
} 

int  
OGLTexture::draw_id_ref() 
{ 
   ColorIDTexture *tex = (ColorIDTexture*)
      _patch->get_tex(ColorIDTexture::static_name());

   if (tex) {
      // If the GTexture is requesting the ID reference image,
      // draw simple, filled ID-colored triangles. That ought to
      // be good enough for most GTextures, and any fancier ones
      // can override this and draw it their own special way.
      return (
         (use_ref_image() & REF_IMG_ID) ?
         tex->draw(VIEW::peek()) :
         tex->draw_black(VIEW::peek())
         );
   }

   return 0;
} 

int  
OGLTexture::draw_id_sils(bool omit_concave_sils, GLfloat width) 
{
   // This is here for convenience because several GTextures use it.
   //
   // Draw silhouettes into the ID reference image, optionally
   // omitting the concave ones. This is useful in conjunction with
   // drawing filled triangles (black or ID colored) with polygon
   // offset, since the "backfacing" (concave) silhouette edges, which
   // should not be visible, show up incorrectly during rasterization,
   // which really sucks.

   // get the silhouette edges
   EdgeStrip& sils = _patch->cur_sils();

   if (omit_concave_sils) {
      // get an edge strip that omits the concave sil edges
      static EdgeStrip convex_sil_edges = sils.get_filtered(ConvexEdgeFilter());
      ColorIDTexture::draw_edges(&convex_sil_edges, width);
   } else {
      ColorIDTexture::draw_edges(&sils, width);
   }

   return 0;
}
   
int  
OGLTexture::draw_id_triangles(bool   use_polygon_offset, 
                              bool   draw_id_colors,
                              double offset_factor,
                              double offset_units) 
{
   // Another convenience method ... works well with the previous one.

   // draw triangles with ID colors, or black
   ColorIDTexture *tex = (ColorIDTexture*)
      _patch->get_tex(ColorIDTexture::static_name());
   if (tex) {
      if (use_polygon_offset)
         GL_VIEW::init_polygon_offset((float)offset_factor,
                                      (float)offset_units);
      if (draw_id_colors) tex->draw(VIEW::peek());
      else                tex->draw_black(VIEW::peek());
      if (use_polygon_offset)
         GL_VIEW::end_polygon_offset();
   } else
      err_msg( "OGLTexture::draw_id_triangles: warning -- no ColorIDTexture");

   return _patch->num_faces();
}

int
OGLTexture::draw_id_creases(GLfloat width) 
{
   // Yet another convenience method, for drawing crease id's this time.

   // get the crease edges
   EdgeStrip* creases = _patch->cur_creases();

   ColorIDTexture::draw_edges(creases, width);

   return 0;
}

void 
OGLTexture::draw_vert_and_edge_strips(
   bool disable_lights,
   GLfloat line_width,
   GLfloat point_size,
   bool set_color,
   CCOLOR& color
   ) const 
{
   // most textures need to check for vertex and edge strips, and draw
   // them if needed, and most do so in the same way, so this is here
   // for convenience.

   // edge strips
   if (_patch->num_edge_strips() > 0) {
      if (disable_lights) {
         glDisable(GL_LIGHTING);  // GL_ENABLE_BIT
         disable_lights = 0;
      }
      if (set_color) {
         glColor3dv(color.data());
         set_color = 0;
      }
      glLineWidth(line_width);
      _patch->draw_edge_strips(_cb);
      glLineWidth(1.0); // restore default
   }

   // vertex strips
   if (_patch->num_vert_strips() > 0) {
      if (disable_lights)
         glDisable(GL_LIGHTING);  // GL_ENABLE_BIT
      if (set_color)
         glColor3dv(color.data());
      glPointSize(point_size);
      _patch->draw_vert_strips(_cb);
      glPointSize(1.0); // restore default
   }
}

void 
OGLTexture::check_patch_texture_map()
{
   // XXX - only exists as a hack
   //
   // patches can read in the name of a texture file
   // to be used for the texture map associated with the
   // the patch. but patches can't know about the TEXTUREgl
   // class since lib mesh isn't supposed to know about
   // lib geom (tho it does, for now). anyway, this checks
   // whether the patch got assigned a texture file name
   // and if so it turns it into a TEXTUREgl that it assigns
   // to the patch.

   if (!_patch || _patch->has_texture())
      return;

   Cstr_ptr& n = _patch->texture_file();

   if (n && n != NULL_STR) {
      TEXTUREptr tex = new TEXTUREgl(n);

      if (tex->load_texture()) {
         _patch->set_texture(tex);
      }

      _patch->set_texture_file(NULL_STR);
   }
}

/**********************************************************************
 * BasicTexture:
 **********************************************************************/
int
BasicTexture::draw(CVIEWptr &v)
{
   // okay to draw if the display list time stamp
   // is more recent than the patch's time stamp

   int ret = dl_valid(v);
   
   if (ret==1) glCallList(_dl.dl(v));

   return ret;
}

int
BasicTexture::dl_valid(CVIEWptr &v)
{
   // okay to draw if the display list time stamp
   // is more recent than the patch's time stamp
   if (_dl.valid(v, (int) _patch->stamp())) {
      return 1;
   } else {
      return 0;
   }
}

// end of file basic_texture.C

---