OSGPolygon.cc

Go to the documentation of this file.

#include <esg/OSGPolygon.h>

using namespace esg;

void OSGPolygon::_duplicate_attributes(const Geometry& src)
{
    // We do not want to call the _Surface::duplicate_attributes()
    // because it clones _vindices and _nindices which we do not use.
    // Therefore jump over these parent calsses 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          = ((OSGPolygon&)src)._nVert;
    _vertices       = ((OSGPolygon&)src)._vertices;
    _normals        = ((OSGPolygon&)src)._normals;
    _normal.set(((OSGPolygon&)src)._normal);
    _normalFixed    = ((OSGPolygon&)src)._normalFixed;
    _fxyz           = ((OSGPolygon&)src)._fxyz;
    _edgeProjection = ((OSGPolygon&)src)._edgeProjection;
    _vindices       = NULL;
    _nindices       = NULL;

    _proj = NULL;
    _tangible = true;

    // finally we duplicate new attributes
    _firstVertexOfPrimitive = ((OSGPolygon&)src)._firstVertexOfPrimitive;
    _firstVertex            = ((OSGPolygon&)src)._firstVertex;
    _vertexMode             = ((OSGPolygon&)src)._vertexMode;
    _globalVertexArray      = ((OSGPolygon&)src)._globalVertexArray;
    _pDrawArray             = ((OSGPolygon&)src)._pDrawArray;
}

Vector3 OSGPolygon::_get_vertex(unsigned index) const
{
    unsigned int vindex = index;

#if 0
    if (_vertexMode == osg::PrimitiveSet::TRIANGLE_FAN && index == 2) {
        vindex = _firstVertexOfPrimitive;
    } else {
        // get index with respect to primitive type
        switch (_primitiveType) {
        case osg::PrimitiveSet::DrawElementsUBytePrimitiveType: 
            vindex = (unsigned int) (*static_cast<osg::DrawElementsUByte*>(_pDrawArray))[index];
            break;
        case osg::PrimitiveSet::DrawElementsUShortPrimitiveType: 
            vindex = (unsigned int) (*static_cast<osg::DrawElementsUShort*>(_pDrawArray))[index];
            break;
        case osg::PrimitiveSet::DrawElementsUIntPrimitiveType:
            vindex = (unsigned int) (*static_cast<osg::DrawElementsUInt*>(_pDrawArray))[index];
            break;
        case osg::PrimitiveSet::PrimitiveType:
        case osg::PrimitiveSet::DrawArraysPrimitiveType:
        case osg::PrimitiveSet::DrawArrayLengthsPrimitiveType:
        default:
            vindex = index;
            break;
        }
        vindex += _firstVertexOfPrimitive + _firstVertex;
    }
#endif

    // get index to global array
    switch (_vertexMode) {
    case osg::PrimitiveSet::TRIANGLES:
    case osg::PrimitiveSet::QUADS:
    case osg::PrimitiveSet::TRIANGLE_STRIP:
    case osg::PrimitiveSet::QUAD_STRIP:
    case osg::PrimitiveSet::POLYGON:
        vindex += _firstVertexOfPrimitive + _firstVertex;
        break;
    case osg::PrimitiveSet::TRIANGLE_FAN:
        if (index < 2) vindex += _firstVertexOfPrimitive + _firstVertex;
        vindex = ((index == 2)
                  ? _firstVertexOfPrimitive
                  : _firstVertexOfPrimitive + _firstVertex + index);
        break;
    default:
        fprintf(stderr,"OSGPolygon::_get_vertex(): Unsupported vertex mode\n");
        return Vector3(0,0,0);
        break;
    }

    // adjust index in accord to primitive type
    switch (_primitiveType) {
    case osg::PrimitiveSet::DrawElementsUBytePrimitiveType:
        vindex = (*static_cast<osg::DrawElementsUByte*>(_pDrawArray))[vindex];
        break;
    case osg::PrimitiveSet::DrawElementsUShortPrimitiveType:
        vindex = (*static_cast<osg::DrawElementsUShort*>(_pDrawArray))[vindex];
        break;
    case osg::PrimitiveSet::DrawElementsUIntPrimitiveType: // zbytecne ??
        vindex = (*static_cast<osg::DrawElementsUInt*>(_pDrawArray))[vindex];
        break;
    case osg::PrimitiveSet::PrimitiveType:
    case osg::PrimitiveSet::DrawArraysPrimitiveType:
    case osg::PrimitiveSet::DrawArrayLengthsPrimitiveType:
        // ???
        break;
    default:
        break;
    }

    return Vector3((*_globalVertexArray)[vindex].x(),
                   (*_globalVertexArray)[vindex].y(),
                   (*_globalVertexArray)[vindex].z());
}


Vector3 OSGPolygon::_get_vert_normal(unsigned index) const
{
    unsigned int vindex = index;

    if (_normal_binding == osg::Geometry::BIND_PER_VERTEX) {
        // get index to global array
        switch (_vertexMode) {
        case osg::PrimitiveSet::TRIANGLES:
        case osg::PrimitiveSet::QUADS:
        case osg::PrimitiveSet::TRIANGLE_STRIP:
        case osg::PrimitiveSet::QUAD_STRIP:
        case osg::PrimitiveSet::POLYGON:
            vindex += _firstVertexOfPrimitive + _firstVertex;
            break;
        case osg::PrimitiveSet::TRIANGLE_FAN:
            if (index < 2) vindex += _firstVertexOfPrimitive + _firstVertex;
            vindex = ((index == 2)
                      ? _firstVertexOfPrimitive
                      : _firstVertexOfPrimitive + _firstVertex + index);
            break;
        default:
            fprintf(stderr,"OSGPolygon::_get_vertex(): Unsupported vertex mode\n");
            return Vector3(0,0,0);
            break;
        }
        
        // adjust index in accord to primitive type
        switch (_primitiveType) {
        case osg::PrimitiveSet::DrawElementsUBytePrimitiveType:
            vindex = (*static_cast<osg::DrawElementsUByte*>(_pDrawArray))[vindex];
            break;
        case osg::PrimitiveSet::DrawElementsUShortPrimitiveType:
            vindex = (*static_cast<osg::DrawElementsUShort*>(_pDrawArray))[vindex];
            break;
        case osg::PrimitiveSet::DrawElementsUIntPrimitiveType: // zbytecne ??
            vindex = (*static_cast<osg::DrawElementsUInt*>(_pDrawArray))[vindex];
            break;
        case osg::PrimitiveSet::PrimitiveType:
        case osg::PrimitiveSet::DrawArraysPrimitiveType:
        case osg::PrimitiveSet::DrawArrayLengthsPrimitiveType:
            // ???
            break;
        default:
            break;
        }
        
        return Vector3((*_globalNormalArray)[vindex].x(),
                       (*_globalNormalArray)[vindex].y(),
                       (*_globalNormalArray)[vindex].z());
        
    }

    fprintf(stderr,"OSGPolygon::_get_vert_normal(): Non-existing vertex normal required.\n");
    return Vector3(0.0, 0.0, 0.0);
}



OSGPolygon::OSGPolygon(GLint                   fgv,
                       GLint                   fv,
                       osg::PrimitiveSet::Type t,
                       osg::PrimitiveSet::Mode m,
                       osg::Vec3Array *        a,
                       osg::PrimitiveSet *     d,
                       osg::Vec3Array *        n,
                       osg::Geometry::AttributeBinding nb)
    : _firstVertexOfPrimitive(fgv),
      _firstVertex(fv),
      _primitiveType(t),
      _vertexMode(m),
      _globalVertexArray(a),
      _pDrawArray(d),
      _globalNormalArray(n),
      _normal_binding(nb)
{
    _vertices = NULL;
    _normals  = NULL;
    _vindices = NULL;
    _nindices = NULL;

    if (_vertexMode == osg::PrimitiveSet::TRIANGLES ||
        _vertexMode == osg::PrimitiveSet::TRIANGLE_STRIP ||
        _vertexMode == osg::PrimitiveSet::TRIANGLE_FAN) _nVert = 3;
    else
        if (_vertexMode == osg::PrimitiveSet::QUADS ||
            _vertexMode == osg::PrimitiveSet::QUAD_STRIP) _nVert = 4;
        else _nVert = 0;

    _normal.set(_get_facet_normal());
    _normalFixed = false;
    _fxyz = - _normal.dot(_get_vertex(0));
    _set_edge_projection();

    _tangible = true;
}

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

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

Vertex3 OSGPolygon::getVertex(unsigned index) const 
{
    return ((_pDrawArray && _globalVertexArray)
            ? _get_vertex(index)
            :Vertex3(0,0,0));
}

Vertex3 OSGPolygon::getVertNormal(unsigned index) const 
{
    return ((haveVertNormals()) ? _get_vert_normal(index) : Vertex3(0,0,0));
}

bool OSGPolygon::haveVertNormals() const
{
    return (_pDrawArray &&
            _globalNormalArray &&
            _normal_binding == osg::Geometry::BIND_PER_VERTEX);
}

---