tools::sg::polyhedron Class Reference

Inheritance diagram for tools::sg::polyhedron:

Collaboration diagram for tools::sg::polyhedron:

Public Types
enum	update_what { faces = 0, lines = 1, faces_and_lines }
typedef tessellate::prims_t	prims_t

Public Member Functions
virtual const desc_fields &	node_desc_fields () const
virtual void	render (render_action &a_action)
virtual void	bbox (bbox_action &a_action)
virtual void	pick (pick_action &a_action)
	polyhedron ()
virtual	~polyhedron ()
	polyhedron (const polyhedron &a_from)
polyhedron &	operator= (const polyhedron &a_from)
void	update_sg (std::ostream &a_out, const update_what &a_what)
const std::vector< float > &	xyzs () const
Public Member Functions inherited from tools::sg::node
virtual void *	cast (const std::string &a_class) const
virtual const std::string &	s_cls () const =0
virtual node *	copy () const =0
virtual unsigned int	cls_version () const
virtual void	search (search_action &a_action)
virtual void	get_matrix (get_matrix_action &a_action)
virtual bool	write (write_action &a_action)
virtual void	event (event_action &)
virtual bool	read (read_action &a_action)
virtual void	is_visible (visible_action &)
virtual void	protocol_one_fields (std::vector< field * > &a_fields) const
virtual bool	draw_in_frame_buffer () const
virtual bool	touched ()
virtual void	reset_touched ()
	node ()
virtual	~node ()
void	touch ()
field &	field_from_desc (const field_desc &a_desc) const
void	dump_field_descs (std::ostream &a_out) const
field *	find_field_by_name (const std::string &a_name) const
Public Member Functions inherited from tools::sg::gstos
size_t	num_gstos () const

Public Attributes
hep::sf_polyhedron	ph
sf< bool >	solid
sf< bool >	reduced_wire_frame
sf< bool >	enforce_edges

Protected Member Functions
virtual unsigned int	create_gsto (std::ostream &a_out, render_manager &a_mgr)
void	_clear ()
Protected Member Functions inherited from tools::sg::node
	node (const node &)
node &	operator= (const node &)
void	add_field (field *a_field)
bool	write_fields (write_action &a_action)
bool	read_fields (read_action &a_action)
field_desc::offset_t	field_offset (const field *a_field) const
field *	find_field (const field_desc &a_rdesc) const
void	check_fields (std::ostream &a_out) const
Protected Member Functions inherited from tools::sg::gstos
	gstos ()
virtual	~gstos ()
	gstos (const gstos &)
gstos &	operator= (const gstos &a_from)
unsigned int	get_tex_id (std::ostream &a_out, render_manager &a_mgr, const img_byte &a_img, bool a_NEAREST)
unsigned int	get_gsto_id (std::ostream &a_out, render_manager &a_mgr)
void	clean_gstos ()
void	clean_gstos (render_manager *a_mgr)
unsigned int	_find (render_manager *a_mgr)

Protected Attributes
std::vector< float >	m_xyzs
tessellate *	m_tess
std::vector< prims_t >	m_primss
size_t	m_size
bool	m_draw_edges
Protected Attributes inherited from tools::sg::gstos
std::vector< std::pair< unsigned int, render_manager * > >	m_gstos

Detailed Description

Definition at line 23 of file polyhedron.

Member Typedef Documentation

prims_t

typedef tessellate::prims_t tools::sg::polyhedron::prims_t

Definition at line 50 of file polyhedron.

Member Enumeration Documentation

update_what

enum tools::sg::polyhedron::update_what

Enumerator
faces
lines
faces_and_lines

Definition at line 336 of file polyhedron.

                   {
    faces = 0,
    lines = 1,
    faces_and_lines
  };

Constructor & Destructor Documentation

polyhedron() [1/2]

tools::sg::polyhedron::polyhedron ( )

inline

Definition at line 293 of file polyhedron.

  :parent()
  ,ph(hep::polyhedron())
  ,solid(true)
  ,reduced_wire_frame(true)
  ,enforce_edges(false)
 
  ,m_tess(0)
  {
    add_fields();
  }

~polyhedron()

virtual tools::sg::polyhedron::~polyhedron ( )

inlinevirtual

Definition at line 304 of file polyhedron.

                       {
    _clear();
    delete m_tess;
  }

polyhedron() [2/2]

tools::sg::polyhedron::polyhedron ( const polyhedron &  a_from )

inline

Definition at line 309 of file polyhedron.

  :parent(a_from)
  ,gstos(a_from)
  ,ph(a_from.ph)
  ,solid(a_from.solid)
  ,reduced_wire_frame(a_from.reduced_wire_frame)
  ,enforce_edges(a_from.enforce_edges)
 
  ,m_xyzs(a_from.m_xyzs)
  ,m_tess(0)
  {
    add_fields();
  }

Member Function Documentation

_clear()

void tools::sg::polyhedron::_clear ( )

inlineprotected

Definition at line 480 of file polyhedron.

               {
    tools_vforit(prims_t,m_primss,it) raw_clear(*it);
    m_primss.clear();
    m_xyzs.clear();
  }

bbox()

virtual void tools::sg::polyhedron::bbox ( bbox_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 254 of file polyhedron.

                                           {
    if(touched()) {
      update_sg(a_action.out(),lines);
      reset_touched();
    }
    if(solid.value()) {
      tools_vforcit(prims_t,m_primss,itt) {
        const prims_t& prims = *itt;
        tools_vforcit(tess_prim*,prims,it) {
          const tess_prim& item = *(*it);
          const std::vector<float>& coords = item.m_coords;
          a_action.add_points(coords);
        }
      }
    } else {
      a_action.add_points(m_xyzs);
    }
  }

create_gsto()

virtual unsigned int tools::sg::polyhedron::create_gsto ( std::ostream &  a_out, render_manager &  a_mgr  )

inlineprotectedvirtual

Reimplemented from tools::sg::gstos.

Definition at line 53 of file polyhedron.

                                                                            {
    m_size = 0;
    if(solid.value()) {
 
      size_t sz = 0;
 
      if(m_draw_edges) sz += m_xyzs.size();
 
     {tools_vforcit(prims_t,m_primss,itt) {
        const prims_t& prims = *itt;
        tools_vforcit(tess_prim*,prims,it) {
          const tess_prim& item = *(*it);
          const std::vector<float>& coords = item.m_coords;
          const std::vector<float>& norms = item.m_norms;
          if(coords.empty()) continue;
          if(norms.size()!=coords.size()) {
            a_out << "tools::sg::polyhedron::create_gsto :"
                  << " bad number of normals."
                  << std::endl;
            continue;
          }
          sz += coords.size()+norms.size();
        }
      }}
 
      if(sz) {
 
        float* buffer = new float[sz];
        char* pos = (char*)buffer;
        size_t psz = 0;
 
        if(m_draw_edges) {
          if(m_xyzs.size()) {
            size_t _sz = m_xyzs.size()*sizeof(float);
            ::memcpy(pos,vec_data<float>(m_xyzs),_sz);
            pos += _sz;
            psz += _sz;
            m_size = m_xyzs.size();
            //m_xyzs.clear(); //we need them for pick,write,...
          }
        }
 
       {tools_vforcit(prims_t,m_primss,itt) {
          const prims_t& prims = *itt;
          tools_vforcit(tess_prim*,prims,it) {
            tess_prim& item = *(*it);
            const std::vector<float>& coords = item.m_coords;
            const std::vector<float>& norms = item.m_norms;
            if(coords.empty()) continue;
            if(norms.size()!=coords.size()) continue;
 
            item.m_size = coords.size();
 
           {item.m_pos_coords = psz;
            size_t _sz = coords.size()*sizeof(float);
            ::memcpy(pos,vec_data<float>(coords),_sz);
            pos += _sz;
            psz += _sz;}
 
           {item.m_pos_norms = psz;
            size_t _sz = norms.size()*sizeof(float);
            ::memcpy(pos,vec_data<float>(norms),_sz);
            pos += _sz;
            psz += _sz;}
 
            // we don't need coords, norms for rendering
            // but needed for pick,write...
            //coords.clear();
            //norms.clear();
 
            //we still need m_prims.
 
          }
        }}
 
        unsigned int id = a_mgr.create_gsto_from_data(sz,buffer);
        delete [] buffer;
        return id;
      }
 
    } else {
      m_size = m_xyzs.size();
      return a_mgr.create_gsto_from_data(m_xyzs);
    }
    return 0;
  }

node_desc_fields()

virtual const desc_fields& tools::sg::polyhedron::node_desc_fields ( ) const

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 31 of file polyhedron.

                                                      {
    TOOLS_FIELD_DESC_NODE_CLASS(tools::sg::polyhedron)
    static const desc_fields s_v(parent::node_desc_fields(),4, //WARNING : take care of count.
      TOOLS_ARG_FIELD_DESC(ph),
      TOOLS_ARG_FIELD_DESC(solid),
      TOOLS_ARG_FIELD_DESC(reduced_wire_frame),
      TOOLS_ARG_FIELD_DESC(enforce_edges)
    );
    return s_v;
  }

operator=()

polyhedron& tools::sg::polyhedron::operator= ( const polyhedron &  a_from )

inline

Definition at line 322 of file polyhedron.

                                                 {
    parent::operator=(a_from);
    gstos::operator=(a_from);
    ph = a_from.ph;
    solid = a_from.solid;
    reduced_wire_frame = a_from.reduced_wire_frame;
    enforce_edges = a_from.enforce_edges;
 
    m_xyzs = a_from.m_xyzs;
 
    return *this;
  }

pick()

virtual void tools::sg::polyhedron::pick ( pick_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 273 of file polyhedron.

                                           {
    if(touched()) {
      update_what what = solid.value()?faces:lines;
      update_sg(a_action.out(),what);
      reset_touched();
    }
    if(solid.value()) {
      tools_vforcit(prims_t,m_primss,itt) {
        const prims_t& prims = *itt;
        tools_vforcit(tess_prim*,prims,it) {
          const tess_prim& item = *(*it);
          const std::vector<float>& coords = item.m_coords;
          if(a_action.add__primitive(*this,item.m_mode,coords,true)) return;
        }
      }
    } else {
      a_action.add__lines(*this,m_xyzs,true);
    }
  }

render()

virtual void tools::sg::polyhedron::render ( render_action &  a_action )

inlinevirtual

Reimplemented from tools::sg::node.

Definition at line 141 of file polyhedron.

                                               {
    const state& state = a_action.state();
 
    bool draw_edges = false;
    if(solid.value()) {
      draw_edges = state.m_GL_LIGHTING?false:true;
      if(enforce_edges.value()) draw_edges = true;
    }
 
    if( touched() ||
       (draw_edges && m_xyzs.empty()) ||
       (solid.value() && m_primss.empty())  ){
      update_what what = lines;
      if(solid.value()) what = draw_edges?faces_and_lines:faces;
      update_sg(a_action.out(),what);
      reset_touched();
    }
 
    unsigned int _id = 0;
    if(state.m_use_gsto) {
      m_draw_edges = draw_edges;
      _id = get_gsto_id(a_action.out(),a_action.render_manager());
    } else {
      clean_gstos(&a_action.render_manager());
    }
 
    //a_action.out() << "debug : tools::sg::polyhedron::render_action :"
    //               << " m_xyzs.size() " << m_xyzs.size()
    //               << " m_primss.size() " << m_primss.size()
    //               << std::endl;
 
    if(solid.value()) {
 
      if(_id) {
 
        a_action.begin_gsto(_id);
        if(draw_edges && m_size) {
          //Same logic as Inventor SoLightModel.model = BASE_COLOR.
          a_action.set_lighting(false);
          a_action.color4f(0,0,0,1);
 
          a_action.draw_gsto_v(gl::lines(),m_size/3,0);
 
          //pushes back the filled polygons to avoid z-fighting with lines
          a_action.set_polygon_offset(true);
 
          a_action.color4f(state.m_color);
          a_action.set_lighting(state.m_GL_LIGHTING);
        }
 
       {tools_vforcit(prims_t,m_primss,itt) {
          const prims_t& prims = *itt;
          tools_vforcit(tess_prim*,prims,it) {
            const tess_prim& item = *(*it);
            a_action.draw_gsto_vn(item.m_mode,item.m_size/3,item.m_pos_coords,item.m_pos_norms);
          }
        }}
 
        a_action.set_polygon_offset(state.m_GL_POLYGON_OFFSET_FILL);
        a_action.end_gsto();
      } else {
 
        if(draw_edges){
          if(m_xyzs.size()) {
            //Same logic as Inventor SoLightModel.model = BASE_COLOR.
            a_action.set_lighting(false);
            a_action.color4f(0,0,0,1);
 
            a_action.draw_vertex_array(gl::lines(),m_xyzs);
 
            //pushes back the filled polygons to avoid z-fighting with lines
            a_action.set_polygon_offset(true);
 
            a_action.color4f(state.m_color);
            a_action.set_lighting(state.m_GL_LIGHTING);
          }
        }
 
       {tools_vforcit(prims_t,m_primss,itt) {
          const prims_t& prims = *itt;
          tools_vforcit(tess_prim*,prims,it) {
            const tess_prim& item = *(*it);
            const std::vector<float>& coords = item.m_coords;
            if(coords.empty()) continue;
            const std::vector<float>& norms = item.m_norms;
            if(norms.size()!=coords.size()) {
              a_action.out() << "tools::sg::polyhedron::render :"
                             << " bad number of normals."
                             << std::endl;
              continue;
            }
            a_action.draw_vertex_normal_array(item.m_mode,coords,norms);
          }
        }}
        a_action.set_polygon_offset(state.m_GL_POLYGON_OFFSET_FILL);
      }
 
    } else { //not solid
      //Same logic as Inventor SoLightModel.model = BASE_COLOR.
      a_action.set_lighting(false); // do we want that ?
 
      if(_id) {
        a_action.begin_gsto(_id);
        a_action.draw_gsto_v(gl::lines(),m_size/3,0);
        a_action.end_gsto();
      } else {
        a_action.draw_vertex_array(gl::lines(),m_xyzs);
      }
 
      a_action.set_lighting(state.m_GL_LIGHTING);
    }
  }

update_sg()

void tools::sg::polyhedron::update_sg ( std::ostream &  a_out, const update_what &  a_what  )

inline

Definition at line 342 of file polyhedron.

                                                              {
    //a_out << "debug : tools::sg::polyhedron::update_sg" << std::endl;
 
    clean_gstos(); //must reset for all render_manager.
 
    _clear();
 
    const hep::polyhedron& sbPolyhedron = ph.value();
    if(sbPolyhedron.GetNoFacets()<=0) {
      //a_out << "tools::sg::polyhedron::update_sg : abnormal polyhedron." << std::endl;
      return; // Abnormal polyhedron.
    }
 
    if((a_what==faces)||(a_what==faces_and_lines)) {
 
      std::vector<double> doubles;
 
      vec3d unitNormal;
      vec3d* pV = sbPolyhedron.GetPV();
 
      // Assume all facets are convex quadrilaterals :
      bool notLastFace;
      do {
        notLastFace = sbPolyhedron.GetNextUnitNormal(unitNormal);
 
        doubles.clear(); //begin POLYGON
 
        bool notLastEdge;
        int edgeFlag = 1;
        do {
          // optimize to avoid copying vec3f.
          //notLastEdge = sbPolyhedron.GetNextVertex(vertex,edgeFlag);
          int index;
          notLastEdge = sbPolyhedron.GetNextVertexIndex(index,edgeFlag);
          vec3d* vertex = pV+index; //WARNING : must not be modified !
 
          doubles.push_back((*vertex)[0]);
          doubles.push_back((*vertex)[1]);
          doubles.push_back((*vertex)[2]);
 
        } while (notLastEdge);
 
        if(!m_tess) m_tess = new tessellate(a_out);
 
        m_primss.push_back(prims_t());
        prims_t& prims = m_primss.back();
 
        m_tess->do_it(doubles.size()/3,vec_data(doubles),prims);
 
        m_tess->clear();
 
      } while (notLastFace);
    }
 
    if((a_what==lines)||(a_what==faces_and_lines)) {
      float pvbx = 0;
      float pvby = 0;
      float pvbz = 0;
 
      float pvex,pvey,pvez;
 
      vec3d unitNormal;
      vec3d* pV = sbPolyhedron.GetPV();
 
      bool notLastFace;
      do {
        notLastFace = sbPolyhedron.GetNextUnitNormal(unitNormal);
 
        // Treat edges :
        int edgeFlag = 1;
        int prevEdgeFlag = edgeFlag;
        bool notLastEdge;
        bool firstEdge = true;
        do {
          int index;
          notLastEdge = sbPolyhedron.GetNextVertexIndex(index,edgeFlag);
          vec3d* vertex = pV+index; //WARNING : must not be modified !
 
          if(!reduced_wire_frame) edgeFlag = 1;
          if(firstEdge) {
            if(edgeFlag) {
              pvbx = (float)(*vertex)[0];
              pvby = (float)(*vertex)[1];
              pvbz = (float)(*vertex)[2];
            } else {
            }
            firstEdge = false;
            prevEdgeFlag = edgeFlag;
          } else {
            if(edgeFlag!=prevEdgeFlag) {
              if(edgeFlag) { // Pass to a visible edge :
                pvbx = (float)(*vertex)[0];
                pvby = (float)(*vertex)[1];
                pvbz = (float)(*vertex)[2];
              } else { // Pass to an invisible edge :
                pvex = (float)(*vertex)[0];
                pvey = (float)(*vertex)[1];
                pvez = (float)(*vertex)[2];
 
                m_xyzs.push_back(pvbx);
                m_xyzs.push_back(pvby);
                m_xyzs.push_back(pvbz);
 
                m_xyzs.push_back(pvex);
                m_xyzs.push_back(pvey);
                m_xyzs.push_back(pvez);
              }
              prevEdgeFlag = edgeFlag;
            } else {
              if(edgeFlag) {
                pvex = (float)(*vertex)[0];
                pvey = (float)(*vertex)[1];
                pvez = (float)(*vertex)[2];
 
                m_xyzs.push_back(pvbx);
                m_xyzs.push_back(pvby);
                m_xyzs.push_back(pvbz);
 
                m_xyzs.push_back(pvex);
                m_xyzs.push_back(pvey);
                m_xyzs.push_back(pvez);
 
                pvbx = pvex;
                pvby = pvey;
                pvbz = pvez;
              } else {
              }
            }
          }
        } while (notLastEdge);
      } while (notLastFace);
 
    }
  }

xyzs()

const std::vector<float>& tools::sg::polyhedron::xyzs ( ) const

inline

Definition at line 477 of file polyhedron.

{return m_xyzs;}

Member Data Documentation

enforce_edges

sf<bool> tools::sg::polyhedron::enforce_edges

Definition at line 29 of file polyhedron.

m_draw_edges

bool tools::sg::polyhedron::m_draw_edges

protected

Definition at line 494 of file polyhedron.

m_primss

std::vector<prims_t> tools::sg::polyhedron::m_primss

protected

Definition at line 491 of file polyhedron.

m_size

size_t tools::sg::polyhedron::m_size

protected

Definition at line 493 of file polyhedron.

m_tess

tessellate* tools::sg::polyhedron::m_tess

protected

Definition at line 490 of file polyhedron.

m_xyzs

std::vector<float> tools::sg::polyhedron::m_xyzs

protected

Definition at line 487 of file polyhedron.

ph

hep::sf_polyhedron tools::sg::polyhedron::ph

Definition at line 26 of file polyhedron.

reduced_wire_frame

sf<bool> tools::sg::polyhedron::reduced_wire_frame

Definition at line 28 of file polyhedron.

solid

sf<bool> tools::sg::polyhedron::solid

Definition at line 27 of file polyhedron.

---

The documentation for this class was generated from the following file:

• /Users/barrand/private/dev/softinex/g4tools/g4tools/tools/sg/polyhedron