gfx/EnhancedShapeDrawable.cpp

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2003 Robert Osfield 
 *
 * This library is open source and may be redistributed and/or modified under  
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or 
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the 
 * OpenSceneGraph Public License for more details.
*/
#include <gfx/EnhancedShapeDrawable>
#include <osg/GL>
#include <osg/Notify>

#include <physics/Capsule>

using namespace osg;

using gfx::EnhancedShapeDrawable;
using physics::Capsule;



///////////////////////////////////////////////////////////////////////////////
//
// draw shape
//


class osg::DrawShapeVisitor;



class EnhancedDrawShapeVisitor : public ConstShapeVisitor
{
    public:
    
        EnhancedDrawShapeVisitor(State& state,const TessellationHints* hints):
            _state(state),
            _hints(hints)
        {
        }
    
        virtual void apply(const Capsule&);
        
        State&              _state;
        const TessellationHints*  _hints;
};



void EnhancedDrawShapeVisitor::apply(const Capsule& capsule)
{
    glPushMatrix();

        glTranslatef(capsule.getCenter().x(),capsule.getCenter().y(),capsule.getCenter().z());

        if (!capsule.zeroRotation())
        {
            Matrix rotation(capsule.getRotationMatrix());
            glMultMatrix(rotation.ptr());
        }

        // evaluate hints
        bool createBody = (_hints ? _hints->getCreateBody() : true);
        bool createTop = (_hints ? _hints->getCreateTop() : true);
        bool createBottom = (_hints ? _hints->getCreateBottom() : true);

        unsigned int numSegments = 40;
        if (_hints && _hints->getDetailRatio() != 1.0f) {
            float ratio = _hints->getDetailRatio();
            numSegments = (unsigned int) (numSegments * ratio);
            if (numSegments < MIN_NUM_SEGMENTS)
                numSegments = MIN_NUM_SEGMENTS;
        }
        
        float angleDelta = 2.0f*osg::PI/(float)numSegments;
        float texCoordDelta = 1.0f/(float)numSegments;
        
        float r = cylinder.getRadius();
        float h = cylinder.getHeight();
        
        float basez = -h*0.5f;
        float topz = h*0.5f;
        
        float angle = 0.0f;
        float texCoord = 0.0f;

        // cylinder body
        if (createBody) {
            glBegin(GL_QUAD_STRIP);
        
            for(unsigned int bodyi=0;
                bodyi<numSegments;
                ++bodyi,angle+=angleDelta,texCoord+=texCoordDelta)
            {
                float c = cosf(angle);
                float s = sinf(angle);

                glNormal3f(c,s,0.0f);

                glTexCoord2f(texCoord,1.0f);
                glVertex3f(c*r,s*r,topz);

                glTexCoord2f(texCoord,0.0f);
                glVertex3f(c*r,s*r,basez);
            }

            // do last point by hand to ensure no round off errors.
            glNormal3f(1.0f,0.0f,0.0f);

            glTexCoord2f(1.0f,1.0f);
            glVertex3f(r,0.0f,topz);

            glTexCoord2f(1.0f,0.0f);
            glVertex3f(r,0.0f,basez);
        
            glEnd();
        }

        // cylinder top
        if (createTop) {
            glBegin(GL_TRIANGLE_FAN);
        
            glNormal3f(0.0f,0.0f,1.0f);
            glTexCoord2f(0.5f,0.5f);
            glVertex3f(0.0f,0.0f,topz);

            angle = 0.0f;
            texCoord = 0.0f;
            for(unsigned int topi=0;
                topi<numSegments;
                ++topi,angle+=angleDelta,texCoord+=texCoordDelta)
            {
                float c = cosf(angle);
                float s = sinf(angle);

                glTexCoord2f(c*0.5f+0.5f,s*0.5f+0.5f);
                glVertex3f(c*r,s*r,topz);
            }

            glTexCoord2f(1.0f,0.0f);
            glVertex3f(r,0.0f,topz);
        
            glEnd();
        }

        // cylinder bottom
        if (createBottom) {
            glBegin(GL_TRIANGLE_FAN);
        
            glNormal3f(0.0f,0.0f,-1.0f);
            glTexCoord2f(0.5f,0.5f);
            glVertex3f(0.0f,0.0f,basez);

            angle = osg::PI*2.0f;
            texCoord = 1.0f;
            for(unsigned int bottomi=0;
                bottomi<numSegments;
                ++bottomi,angle-=angleDelta,texCoord-=texCoordDelta)
            {
                float c = cosf(angle);
                float s = sinf(angle);

                glTexCoord2f(c*0.5f+0.5f,s*0.5f+0.5f);
                glVertex3f(c*r,s*r,basez);
            }

            glTexCoord2f(0.0f,0.0f);
            glVertex3f(r,0.0f,basez);
        
            glEnd();
        }

    glPopMatrix();
}




///////////////////////////////////////////////////////////////////////////////
//
// Compute bounding of shape
//

class EnhancedComputeBoundShapeVisitor : public osg::ConstShapeVisitor
{
    public:
    
        EnhancedComputeBoundShapeVisitor(BoundingBox& bb):_bb(bb) {}
    
        virtual void apply(const Capsule&);
        
        BoundingBox&    _bb;
};



void EnhancedComputeBoundShapeVisitor::apply(const Capsule& capsule)
{
    if (capsule.zeroRotation())
    {
        Vec3 halfLengths(capsule.radius(),capsule.radius(),capsule.height()*0.5f+capsule.radius());
        _bb.expandBy(-halfLengths);
        _bb.expandBy(halfLengths);

    }
    else
    {
        float r = capsule.radius();
        float z = capsule.height()*0.5f;

        Vec3 base_1(Vec3(-r,-r,-z-r));
        Vec3 base_2(Vec3(r,-r,-z-r));
        Vec3 base_3(Vec3(r,r,-z-r));
        Vec3 base_4(Vec3(-r,r,-z-r));
    
        Vec3 top_1(Vec3(-r,-r,z+r));
        Vec3 top_2(Vec3(r,-r,z+r));
        Vec3 top_3(Vec3(r,r,z+r));
        Vec3 top_4(Vec3(-r,r,z+r));

        _bb.expandBy(base_1);
        _bb.expandBy(base_2);
        _bb.expandBy(base_3);
        _bb.expandBy(base_4);

        _bb.expandBy(top_1);
        _bb.expandBy(top_2);
        _bb.expandBy(top_3);
        _bb.expandBy(top_4);
    }
}





///////////////////////////////////////////////////////////////////////////////
//
// Accept a primtive functor for each of the shapes.
//

class EnhancedPrimitiveShapeVisitor : public osg::ConstShapeVisitor
{
    public:
    
        EnhancedPrimitiveShapeVisitor(Drawable::PrimitiveFunctor& functor,const TessellationHints* hints):
            _functor(functor),
            _hints(hints) {}

    
        virtual void apply(const Capsule&);
        
        Drawable::PrimitiveFunctor& _functor;
        const TessellationHints*  _hints;
};



void EnhancedPrimitiveShapeVisitor::apply(const Capsule& capsule)
{
    unsigned int numSegments = 40;

    float angleDelta = 2.0f*osg::PI/(float)numSegments;

    float texCoordDelta = 1.0/(float)numSegments;

    float r = capsule.radius();
    float h = capsule.height();

    float basez = -h*0.5f;
    float topz = h*0.5f;

    // cylinder body
    _functor.begin(GL_QUAD_STRIP);

        float angle = 0.0f;
        float texCoord = 0.0f;
        for(unsigned int bodyi=0;
            bodyi<numSegments;
            ++bodyi,angle+=angleDelta,texCoord+=texCoordDelta)
        {

            float c = cosf(angle);
            float s = sinf(angle);

            _functor.vertex(Vec3(c*r,s*r,topz));
            _functor.vertex(Vec3(c*r,s*r,basez));

        }

        // do last point by hand to ensure no round off errors.
        _functor.vertex(Vec3(r,0.0f,topz));
        _functor.vertex(Vec3(r,0.0f,basez));

    _functor.end();


    // cylinder top
    _functor.begin(GL_TRIANGLE_FAN);

        _functor.vertex(Vec3(0.0f,0.0f,topz));

        angle = 0.0f;
        texCoord = 0.0f;
        for(unsigned int topi=0;
            topi<numSegments;
            ++topi,angle+=angleDelta,texCoord+=texCoordDelta)
        {

            float c = cosf(angle);
            float s = sinf(angle);

            _functor.vertex(Vec3(c*r,s*r,topz));

        }

        _functor.vertex(Vec3(r,0.0f,topz));

    _functor.end();

    // cylinder bottom
    _functor.begin(GL_TRIANGLE_FAN);

        _functor.vertex(Vec3(0.0f,0.0f,basez));

        angle = osg::PI*2.0f;
        texCoord = 1.0f;
        for(unsigned int bottomi=0;
            bottomi<numSegments;
            ++bottomi,angle-=angleDelta,texCoord-=texCoordDelta)
        {

            float c = cosf(angle);
            float s = sinf(angle);

            _functor.vertex(Vec3(c*r,s*r,basez));

        }

        _functor.vertex(Vec3(r,0.0f,basez));

    _functor.end();
}


///////////////////////////////////////////////////////////////////////////////
//
// ShapeDrawable itself..
//


EnhancedShapeDrawable::EnhancedShapeDrawable():
{
}

EnhancedShapeDrawable::EnhancedShapeDrawable(Shape* shape,TessellationHints* hints):
  ShapeDrawable(shape, hints)
{
}

EnhancedShapeDrawable::EnhancedShapeDrawable(const ShapeDrawable& pg,const CopyOp& copyop):
    ShapeDrawable(pg,copyop)
{
}

EnhancedShapeDrawable::~EnhancedShapeDrawable()
{
}

void ShapeDrawable::drawImplementation(State& state) const
{
    if (_shape.valid())
    {
      if (base::instanceof(*_shape, const 
      
        glColor4fv(_color.ptr());
    
        EnhancedDrawShapeVisitor dsv(state,_tessellationHints.get());
        
        _shape->accept(dsv);
    }
}

void ShapeDrawable::accept(ConstAttributeFunctor&) const
{
}

void ShapeDrawable::accept(PrimitiveFunctor& pf) const
{
    if (_shape.valid())
    {
        EnhancedPrimitiveShapeVisitor psv(pf,_tessellationHints.get());
        _shape->accept(psv);
    }
}


bool ShapeDrawable::computeBound() const
{
    _bbox.init();


    if (_shape.valid())
    {
        EnhancedComputeBoundShapeVisitor cbsv(_bbox);
        _shape->accept(cbsv);
        _bbox_computed = true;

        return true;
    }

    return false;
}

---