OSGAdapter.cc

Go to the documentation of this file.

#include <esg/OSGAdapter.h>
#include <esg/spacesorting/FDH14Tree.h>
#include <esg/spacesorting/FDH6Tree.h>
#include <esg/spacesorting/SphereTree.h>

using namespace esg;

void OSGAdapter::_put_polygon(osg::Geometry::PrimitiveSetList * pDrawArraysList,
                              osg::Vec3Array                  * pVertArray,
                              osg::Vec3Array * pNormalArray,
                              osg::Geometry::AttributeBinding normal_binding)
{
    unsigned int i;
    osg::PrimitiveSet *pDrawArrays;
    osg::Geometry::PrimitiveSetList::iterator itr;
    int first = 0, count = 0;

    OSGPolygon *osgpolygon;

    i = 0;
    for (itr = pDrawArraysList->begin();
         itr != pDrawArraysList->end();
         itr++)
    {
        pDrawArrays = (*itr).get();


        switch (pDrawArrays->getType()) {
        case osg::PrimitiveSet::PrimitiveType:
            count = pDrawArrays->getNumIndices();
            //std::cout << "Mozny problem1 :(" << std::endl;
            break;
        case osg::PrimitiveSet::DrawArraysPrimitiveType:
            //first = ((osg::DrawArrays *)pDrawArrays)->getFirst();
            count = pDrawArrays->getNumIndices();
            //std::cout << "Mozny problem5 :(   " << first << " " << count << std::endl;
            break;
        case osg::PrimitiveSet::DrawArrayLengthsPrimitiveType:
            count = pDrawArrays->getNumIndices();
            //std::cout << "Mozny problem2 :(" << std::endl;
            break;
        case osg::PrimitiveSet::DrawElementsUBytePrimitiveType:
            count = pDrawArrays->getNumIndices();
            //std::cout << "Mozny problem3 :(   " << count << std::endl;
            break;
        case osg::PrimitiveSet::DrawElementsUShortPrimitiveType:
            count = pDrawArrays->getNumIndices();
            //std::cout << "Bez problemu :)" << std::endl;
            break;
        case osg::PrimitiveSet::DrawElementsUIntPrimitiveType:
            count = pDrawArrays->getNumIndices();
            //std::cout << "Mozny problem4 :(" << std::endl;
            break;
        }

        osg::PrimitiveSet::Mode mode  = (osg::PrimitiveSet::Mode) pDrawArrays->getMode();

        switch (mode) {
        case osg::PrimitiveSet::TRIANGLES:
            //std::cout << "_put_polygon - T" << /*first << "   " << pDrawArrays->getCount() << "   " << pDrawArrays->getNumPrimitives() <<*/ std::endl;
            for (register int j = 0; j < count; j+=3) {
                _pGroupNode->append(new OSGPolygon((GLint) first, (GLint) j,
                                                   pDrawArrays->getType(),
                                                   mode, pVertArray,
                                                   pDrawArrays,
                                                   pNormalArray, normal_binding));
            }
            break;
        case osg::PrimitiveSet::QUADS:
            //std::cout << "_put_polygon - Q" << /*first << "   " << pDrawArrays->getCount() << "   " << pDrawArrays->getNumPrimitives() <<*/ std::endl;
            for (register int j = 0; j < count; j+=4)
                _pGroupNode->append(new OSGPolygon((GLint) first, (GLint) j,
                                                   pDrawArrays->getType(),
                                                   mode,
                                                   pVertArray, pDrawArrays,
                                                   pNormalArray, normal_binding));
            break;
        case osg::PrimitiveSet::TRIANGLE_STRIP:
            //std::cout << "_put_polygon - TS" << std::endl;
            for (register int j = 0; j < count-2; j++) {
                _pGroupNode->append(osgpolygon = new OSGPolygon((GLint) first,
                                                                (GLint) j,
                                                                pDrawArrays->getType(),
                                                                mode,
                                                                pVertArray,
                                                                pDrawArrays,
                                                                pNormalArray,
                                                                normal_binding));
            }
            break;
        case osg::PrimitiveSet::QUAD_STRIP:
            //std::cout << "_put_polygon - QS" << std::endl;
            for (register int j = 0; j < count-3; j+=2)
                _pGroupNode->append(new OSGPolygon((GLint) first, (GLint) j,
                                                   pDrawArrays->getType(),
                                                   mode,
                                                   pVertArray, pDrawArrays,
                                                   pNormalArray,
                                                   normal_binding));
            break;
        case osg::PrimitiveSet::POLYGON:
            //std::cout << "_put_polygon - P" << std::endl;
            _pGroupNode->append(new OSGPolygon((GLint) first, 0,
                                               pDrawArrays->getType(), mode,
                                               pVertArray, pDrawArrays,
                                               pNormalArray, normal_binding));
            break;
        case osg::PrimitiveSet::TRIANGLE_FAN:
            //std::cout << "_put_polygon - TF" << /*first << "   " << pDrawArrays->getCount() <<*/ std::endl;
            first =0;
            for (register int j = 1; j < count-1; j++)
                _pGroupNode->append(new OSGPolygon((GLint) first, (GLint) j,
                                                   pDrawArrays->getType(),
                                                   mode,
                                                   pVertArray,
                                                   pDrawArrays,
                                                   pNormalArray,
                                                   normal_binding));
            break;
        default:
            fprintf(stderr,"OSGFactory::_put_polyon(): Unsupported OSG primitive mode\n");
            break;
        }
    }
}


OSGAdapter::OSGAdapter(osg::Geometry        * pGeometry,
                       unsigned               leafLimit,
                       unsigned               depthLimit,
                       BVList::SplitStrategy  strategy,
                       bvType                 bv)
{
    switch (bv) {
    case BV_FDH14:
        _pGroupNode = new Group(FDH14Tree(leafLimit,depthLimit,true,strategy));
        break;
    case BV_AABB:
        _pGroupNode = new Group(FDH6Tree(leafLimit,depthLimit,true,strategy));
        break;
    case BV_SPHERE:
    default:
        _pGroupNode = new Group(SphereTree(leafLimit,depthLimit,true,strategy));
    }
    
    osg::Vec3 * validArray;
    osg::Vec3Array * pVertArray = (osg::Vec3Array *) pGeometry->getVertexArray();
    osg::Geometry::PrimitiveSetList *pDrawArrays = &(pGeometry->getPrimitiveSetList());

    if (!pDrawArrays || !pVertArray) return;

    validArray = (osg::Vec3*) pVertArray->getDataPointer();
    if (!validArray) return;

    _put_polygon(pDrawArrays,
                 pVertArray,
                 (osg::Vec3Array*) pGeometry->getNormalArray(),
                 pGeometry->getNormalBinding());
    
    _pGroupNode->build();
}

OSGAdapter::OSGAdapter(Geometry             * pGeometry,
                       unsigned               leafLimit,
                       unsigned               depthLimit,
                       BVList::SplitStrategy  strategy,
                       bvType                 bv)
{
    switch (bv) {
    case BV_FDH14:
        _pGroupNode = new Group(FDH14Tree(leafLimit,depthLimit,true,strategy));
        break;
    case BV_AABB:
        _pGroupNode = new Group(FDH6Tree(leafLimit,depthLimit,true,strategy));
        break;
    case BV_SPHERE:
    default:
        _pGroupNode = new Group(SphereTree(leafLimit,depthLimit,true,strategy));
    }

    SceneGraphObject * pObj = new Leaf();
    pObj->setPrivateGeometry(pGeometry);
    _pGroupNode->append(pObj);
    _pGroupNode->build();
}

OSGAdapter::OSGAdapter(AutoPtr<Geometry>    * pGeometry,
                       unsigned               leafLimit,
                       unsigned               depthLimit,
                       BVList::SplitStrategy  strategy,
                       bvType                 bv)
{
    switch (bv) {
    case BV_FDH14:
        _pGroupNode = new Group(FDH14Tree(leafLimit,depthLimit,true,strategy));
        break;
    case BV_AABB:
        _pGroupNode = new Group(FDH6Tree(leafLimit,depthLimit,true,strategy));
        break;
    case BV_SPHERE:
    default:
        _pGroupNode = new Group(SphereTree(leafLimit,depthLimit,true,strategy));
    }

    SceneGraphObject * pObj = new Leaf();
    pObj->setSharedGeometry(pGeometry);
    _pGroupNode->append(pObj);
    _pGroupNode->build();
}

double* OSGAdapter::getVertices(Matrix4 * pTrMat, unsigned * num)
{
    if (!num) return NULL;
    *num = 0;

    BVH* pBVH = (BVH*) _pGroupNode->getRepository();
    if (!pBVH) return NULL;

    IteratorSDS* pIter = (IteratorSDS*) pBVH->createIterator();
    if (!pIter) return NULL;

    List<OSGPolygon> list;
    pIter->initChildrenSearch();
    OSGPolygon * pObj = (OSGPolygon*) pIter->firstChild();
    while (pObj) {
        list.append(pObj);
        pObj = (OSGPolygon*) pIter->nextChild();
    }

    *num = list.length() * 9;
    double* array = new double [*num];

    pObj = list.firstItem();
    unsigned j = 0;
    Vector3  v;
    while (pObj) {
                for (unsigned i = 0; i < 3; i++) {
                        v.set(pObj->getVertex(i));
                        if (pTrMat) pTrMat->transform(v);
                        array[j++] = v.x;
                        array[j++] = v.y;
                        array[j++] = v.z;
                }
        pObj = list.nextItem();
    }

    return array;
}

double OSGAdapter::distance(Matrix4*    pMatA,
                            OSGAdapter& adapter,
                            Matrix4*    pMatB,
                            BVH::Node** ppNodeA,
                            BVH::Node** ppNodeB,
                            Vector3*    pDir,
                            unsigned    d1,
                            unsigned    d2)
{
    BVH* pBVH1 = (BVH*) _pGroupNode->getRepository();
    BVH* pBVH2 = (BVH*) adapter._pGroupNode->getRepository();
    
    return ((pBVH1 && pBVH2) 
            ? pBVH1->distance(pMatA,*pBVH2,pMatB,ppNodeA,ppNodeB,pDir,d1,d2) 
            : -MAXDOUBLE);
}

bool OSGAdapter::separation(Matrix4*    pMatA,
                            OSGAdapter& adapter,
                            Matrix4*    pMatB,
                            Vector3*    pDir,
                            unsigned    d1,
                            unsigned    d2)
{
    BVH* pBVH1 = (BVH*) _pGroupNode->getRepository();
    BVH* pBVH2 = (BVH*) adapter._pGroupNode->getRepository();
    
    return ((pBVH1 && pBVH2)
            ? pBVH1->separation(pMatA, *pBVH2, pMatB, pDir, d1, d2)
            : true);
}

Geometry** OSGAdapter::collision(Matrix4*  pMatA,
                                 float x, float y, float z, float r, int* pObj)
{
    BVH* pBVH = (BVH*) _pGroupNode->getRepository();
    return ((pBVH) ? pBVH->collision(pMatA, x, y, z, r, pObj) : NULL);
}

PointEnv* OSGAdapter::rayIntersection(const Matrix4* pTrMat,
                                      const Vector3& origin,
                                      const Vector3& direction,
                                      int            mask,
                                      float          maxDist)
{
    _pGroupNode->setPrivateTransformation((pTrMat)?new Transform(*pTrMat):NULL);

    Intersector intersector;
    intersector.init(mask, maxDist);
    
    RayIntExplorer explorer(origin, direction, &intersector, maxDist);
    explorer.explore(*_pGroupNode);
    PointEnv * pE = explorer.result();

    if (pTrMat && pE) {
        if (pE->mask & ENV_HAVE_INTERSECTION)
            pTrMat->transform(pE->intersection);
        
        if (pE->mask & ENV_HAVE_NORMAL) {
            Matrix3 rMat;
            Vector3 tVec, sVec;
            pTrMat->get(rMat, tVec, sVec);
            rMat.transform(pE->normal);
        }

        pE->mask &= ~ENV_HAVE_TRANSFORMATION;
        pE->mask &= ~ENV_HAVE_ASOC_PRIMITIVE;
    }

    return pE;
}

Interval OSGAdapter::extent(const Matrix4* pTrMat, const Vector3& direction)
{
    _pGroupNode->setPrivateTransformation((pTrMat)?new Transform(*pTrMat):NULL);
    ExtentExplorer explorer(direction);
    explorer.explore(*_pGroupNode);
    return explorer.result();
}

Interval* OSGAdapter::nExtents(const Matrix4* pTrMat,
                               const Vector3* directions,
                               unsigned       nDirs)
{
    _pGroupNode->setPrivateTransformation((pTrMat)?new Transform(*pTrMat):NULL);
    
    NExtentsExplorer explorer(directions, nDirs);
    explorer.explore(*_pGroupNode);

    Interval* ret = new Interval [nDirs];
    for (unsigned i = 0; i < nDirs; i++) ret[i] = explorer.result(i);
    
    return ret;
}

---