_Surface.cc

Go to the documentation of this file.

#include <esg/geometry/_Surface.h>
#include <esg/mesh/PolygonMesh.h>

using namespace esg;

Mesh* _Surface::_mesh(int) const
{
    return NULL;  // unspecified
}

void _Surface::_duplicate_attributes(const SceneGraphObject& src)
{
    _duplicate_attributes((Geometry&)src);
}

void _Surface::_duplicate_attributes(const Geometry& src)
{
    // we do not want to call the Polygon::duplicate_attributes()
    // because it clones all attributes (but we are using shared arrays)
    // Therefore jump over this method and call
    // the Geometry::_duplicate_attributes() instead.
    Geometry::_duplicate_attributes(src);

    // Now we must clone all attributes (including those defined
    // in Polygon class) except the shared arrays. They are referenced.
    _nVert = ((_Surface&)src)._nVert;
    _vertices = ((_Surface&)src)._vertices;
    _normals  = ((_Surface&)src)._normals;
    _normal.set(((_Surface&)src)._normal);
    _normalFixed = ((_Surface&)src)._normalFixed;
    _fxyz = ((_Surface&)src)._fxyz;
    _edgeProjection = ((_Surface&)src)._edgeProjection;

    _vindices = new unsigned [_nVert];
    for (register unsigned i = 0; i < _nVert; i++)
        _vindices[i] = ((_Surface&)src)._vindices[i];

    if (((_Surface&)src).haveVertNormals()) {
        _nindices = new unsigned [_nVert];
        for (register unsigned i = 0; i < _nVert; i++)
            _nindices[i] = ((_Surface&)src)._nindices[i];
    } else
        _nindices = NULL;

    if (((_Surface&)src).haveVertUVCoords()) {
        _uvindices = new unsigned [_nVert];
        for (register unsigned i = 0; i < _nVert; i++)
            _uvindices[i] = ((_Surface&)src)._uvindices[i];
    } else
        _uvindices = NULL;
    
    if (((_Surface&)src)._normals) {
        _normals = new Vector3 [_nVert];
        for (unsigned i = 0; i < _nVert; i++)
            _normals[i].set(((_Surface&)src)._normals[i]);
    } else
        _normals = NULL;

    if (((_Surface&)src)._uvCoords) {
        _uvCoords = new Vector2 [_nVert];
        for (unsigned i = 0; i < _nVert; i++)
            _uvCoords[i].set(((_Surface&)src)._uvCoords[i]);
    } else
        _uvCoords = NULL;

    _tangible = true;
    _proj = NULL;
}

Vertex3 _Surface::_get_vertex(unsigned index) const 
{
    return _vertices[_vindices[index]];
}

Vertex3 _Surface::_get_vert_normal(unsigned index) const 
{
    return _normals[_nindices[index]];
}

Vertex2 _Surface::_get_vert_uv_coord(unsigned index) const 
{
    return _uvCoords[_uvindices[index]];
}

void _Surface::_rotateX(float a)
{
    Matrix3 trMat;
    trMat.rotX(a);
    trMat.transform(_normal);
    _set_edge_projection();
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_rotateY(float a)
{
    Matrix3 trMat;
    trMat.rotY(a);
    trMat.transform(_normal);
    _set_edge_projection();
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_rotateZ(float a)
{
    Matrix3 trMat;
    trMat.rotZ(a);
    trMat.transform(_normal);
    _set_edge_projection();
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_rotate(float a, const Vector3& axis)
{
    Matrix4 trMat;
    Matrix3 rotMat;
    trMat.rotationGL(a, axis);
    trMat.get(rotMat);
    rotMat.transform(_normal);
    _set_edge_projection();
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_rotate(const Matrix3& rotMat)
{
    rotMat.transform(_normal);
    _set_edge_projection();
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_translate(float x, float y, float z)
{
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_transform(const Matrix4& trMat)
{
    Matrix3 rotMat;
    trMat.get(rotMat);
    rotMat.transform(_normal);
    _set_edge_projection();
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz = - _normal.dot(getVertex(0));
}

void _Surface::_scale(float s)
{
    if (_proj) { delete [] _proj; _proj = NULL; }
    _fxyz *= s;
}

_Surface::_Surface()
{
    _vindices  = NULL;
    _nindices  = NULL;
    _uvindices = NULL;
}


//------ public ------

_Surface::_Surface(Vector3*             v,
                   Vector3*             n,
                   Vector2*             uv,
                   unsigned             num,
                   const unsigned*      vind,
                   const unsigned*      nind,
                   const unsigned*      uvind,
                   const Vector3&       norm,
                   bool                 fixedn)
{
  _nVert          = num;
  _vertices       = v;
  _normals        = n;
  _uvCoords       = uv;
  _vindices       = new unsigned [_nVert];
  for (unsigned i = 0; i < _nVert; i++)  _vindices[i] = vind[i];
  _normal.set(norm);
  _normalFixed    = fixedn;
  _fxyz           = - _normal.dot(getVertex(0));
  _proj           = NULL;
  
  if (n && nind) {
      _nindices = new unsigned [_nVert];
      for (unsigned i = 0; i < _nVert; i++) _nindices[i] = nind[i];
  } else 
      _nindices = NULL;

  if (uv && uvind) {
      _uvindices = new unsigned [_nVert];
      for (unsigned i = 0; i < _nVert; i++) _uvindices[i] = uvind[i];
  } else 
      _uvindices = NULL;

  // find projection plane
  _set_edge_projection();
  _tangible = true;
}

_Surface::_Surface(Vector3*             v,
                   Vector3*             n,
                   Vector2*             uv,
                   unsigned             num,
                   const unsigned*      vind,
                   const unsigned*      nind,
                   const unsigned*      uvind)
{
  _nVert          = num;
  _vertices       = v;
  _normals        = n;
  _uvCoords       = uv;
  _vindices       = new unsigned [_nVert];
  for (unsigned i = 0; i < _nVert; i++)  _vindices[i] = vind[i];
  _normal.set(_get_facet_normal());
  _normal.normalize();
  _normalFixed    = false;
  _fxyz           = - _normal.dot(getVertex(0));
  _proj           = NULL;

  if (n && nind) {
      _nindices = new unsigned [_nVert];
      for (unsigned i = 0; i < _nVert; i++) _nindices[i] = nind[i];
  } else 
      _nindices = NULL;

  if (uv && uvind) {
      _uvindices = new unsigned [_nVert];
      for (unsigned i = 0; i < _nVert; i++) _uvindices[i] = uvind[i];
  } else 
      _uvindices = NULL;

  // find projection plane
  _set_edge_projection();

  _tangible = true;
}

_Surface::~_Surface()
{
    if (_vindices)  delete [] _vindices;
    if (_nindices)  delete [] _nindices;
    if (_uvindices) delete [] _uvindices;
}

SceneGraphObject* _Surface::clone() const
{
  _Surface* pRet = new _Surface();
  pRet->_duplicate_attributes((SceneGraphObject&) *this);
  return (SceneGraphObject*) pRet;
}

Geometry* _Surface::clone(const Matrix4* pTrMat) const
{
  _Surface* pRet = new _Surface();
  pRet->_duplicate_attributes((Geometry&) *this);
  if (pTrMat) pRet->_transform(*pTrMat);
  return pRet;
}

void _Surface::dump(const char* intent, const char* tab)
{
    printf("%s geometry PolygonOfSurface {\n", intent);
    if (_normalFixed) 
        printf("%s %s normal %f %f %f\n", intent, tab, _normal.x, _normal.y, _normal.z);
    if (_vindices) {
        printf("%s %s vertexIndices", intent, tab);
        for (register unsigned i = 0; i < _nVert; i++) printf(" %d", _vindices[i]);
        printf("\n");
    }
    if (haveVertNormals()) {
        printf("%s %s vertexNormalIndices", intent, tab);
        for (register unsigned i = 0; i < _nVert; i++)
            for (register unsigned i = 0; i < _nVert; i++) printf(" %d", _nindices[i]);
        printf("\n");
    }
    if (haveVertUVCoords()) {
        printf("%s %s uvCoordIndices", intent, tab);
        for (register unsigned i = 0; i < _nVert; i++) printf(" %d", _uvindices[i]);
        printf("\n");
    }
    printf("%s }\n", intent);
}

Vertex3 _Surface::getVertex(unsigned index) const 
{
    return ((index < _nVert && _vertices && _vindices)
            ? _get_vertex(index)
            :Vertex3(0,0,0));
}

Vertex3 _Surface::getVertNormal(unsigned index) const 
{
    return ((index < _nVert && _normals && _nindices)
            ? _get_vert_normal(index)
            : Vertex3(0,0,0));
}

Vertex2 _Surface::getVertUVCoord(unsigned index) const 
{
    return ((index < _nVert && _uvCoords && _uvindices)
            ? _get_vert_uv_coord(index)
            : Vertex2(0,0));
}

bool _Surface::haveVertNormals() const
{
    return (_normals && _nindices);
}

bool _Surface::haveVertUVCoords() const
{
    return (_uvCoords && _uvindices);
}




void _Surface::__debug()
{
    //fprintf(stderr,"_Surface vertices:\n");
    for (unsigned i = 0; i < _nVert; i++)
        fprintf(stderr,"%f %f %f\n",
                _get_vertex(i).x,_get_vertex(i).y,_get_vertex(i).z);
    //fprintf(stderr,"_Surface normal: %f %f %f\n",_normal.x,_normal.y,_normal.z);
}

---