Simple Geometry
[Geometry]

Functions
GeoPositions3fPtr	osg::makeGeoPositions3fPtr (UInt32 uiSize)
	some workaround functions for Windows problems
Variables
static SimpleMaterialPtr	_defaultMaterial
static SimpleMaterialPtr	_defaultUnlitMaterial
Material Access
MaterialPtr	osg::getDefaultMaterial (void)
MaterialPtr	osg::getDefaultUnlitMaterial (void)
Construction functions
NodePtr	osg::makePlane (Real32 xsize, Real32 ysize, UInt16 hor, UInt16 vert)
GeometryPtr	osg::makePlaneGeo (Real32 xsize, Real32 ysize, UInt16 hor, UInt16 vert)
NodePtr	osg::makeCone (Real32 height, Real32 botradius, UInt16 sides, bool doSide, bool doBottom)
GeometryPtr	osg::makeConeGeo (Real32 height, Real32 botradius, UInt16 sides, bool doSide, bool doBottom)
NodePtr	osg::makeCylinder (Real32 height, Real32 radius, UInt16 sides, bool doSide, bool doTop, bool doBottom)
GeometryPtr	osg::makeCylinderGeo (Real32 height, Real32 radius, UInt16 sides, bool doSide, bool doTop, bool doBottom)
NodePtr	osg::makeConicalFrustum (Real32 height, Real32 topradius, Real32 botradius, UInt16 sides, bool doSide, bool doTop, bool doBottom)
GeometryPtr	osg::makeConicalFrustumGeo (Real32 height, Real32 topradius, Real32 botradius, UInt16 sides, bool doSide, bool doTop, bool doBottom)
NodePtr	osg::makeTorus (Real32 innerRadius, Real32 outerRadius, UInt16 sides, UInt16 rings)
GeometryPtr	osg::makeTorusGeo (Real32 innerRadius, Real32 outerRadius, UInt16 sides, UInt16 rings)
NodePtr	osg::makeSphere (UInt16 depth, Real32 radius)
GeometryPtr	osg::makeSphereGeo (UInt16 depth, Real32 radius)
NodePtr	osg::makeLatLongSphere (UInt16 latres, UInt16 longres, Real32 radius)
GeometryPtr	osg::makeLatLongSphereGeo (UInt16 latres, UInt16 longres, Real32 radius)
NodePtr	osg::makeBox (Real32 xsize, Real32 ysize, Real32 zsize, UInt16 hor, UInt16 vert, UInt16 depth)
GeometryPtr	osg::makeBoxGeo (Real32 xsize, Real32 ysize, Real32 zsize, UInt16 hor, UInt16 vert, UInt16 depth)

---

Detailed Description

SimpleGeometry combines a number of functions to create some specialized geometry very easily. See Simple Geometry for a description.

---

Function Documentation

GeoPositions3fPtr osg::makeGeoPositions3fPtr

(

UInt32

uiSize

)

Definition at line 1295 of file OSGSimpleGeometry.cpp.

References osg::GeoProperty< GeoPropertyDesc >::create().

{
    GeoPositions3fPtr returnValue = GeoPositions3f::create();

    returnValue->resize(uiSize);

    return returnValue;
}

MaterialPtr osg::getDefaultMaterial

(

void

)

Access the default Material for Simple Geometry. Also useful whenever an arbitrary material is needed.

Definition at line 71 of file OSGSimpleGeometry.cpp.

References osg::addRefCP(), osg::beginEditCP(), osg::SimpleMaterialBase::create(), osg::endEditCP(), and osg::NullFC.

Referenced by osg::MaterialDrawable::drawActionEnterHandler(), osg::makeBoxGeo(), osg::makeConicalFrustumGeo(), osg::makeLatLongSphereGeo(), osg::makePlaneGeo(), osg::makeSphereGeo(), osg::SwitchMaterial::makeState(), osg::makeTorusGeo(), osg::SwitchMaterial::rebuildState(), osg::MaterialDrawable::renderActionEnterHandler(), and osg::VRMLWriteAction::writeMaterial().

{
    if(_defaultMaterial == NullFC)
    {
        _defaultMaterial = SimpleMaterial::create();

        beginEditCP(_defaultMaterial);
        _defaultMaterial->setDiffuse(Color3f(.7,.7,.5));
        _defaultMaterial->setAmbient(Color3f(0.1,0.1,0.1));
        _defaultMaterial->setSpecular(Color3f(1,1,1));
        _defaultMaterial->setShininess(20);
        endEditCP  (_defaultMaterial);

        addRefCP(_defaultMaterial);
    }
    
    return _defaultMaterial;
}

MaterialPtr osg::getDefaultUnlitMaterial

(

void

)

Access the default unlit Material. Useful whenever an arbitrary unlit material is needed.

Definition at line 99 of file OSGSimpleGeometry.cpp.

References osg::addRefCP(), osg::beginEditCP(), osg::SimpleMaterialBase::create(), osg::endEditCP(), and osg::NullFC.

Referenced by VolumeDrawWrapper::drop().

{
    if(_defaultUnlitMaterial == NullFC)
    {
        _defaultUnlitMaterial = SimpleMaterial::create();

        beginEditCP(_defaultUnlitMaterial);
        _defaultUnlitMaterial->setDiffuse(Color3f(1,1,.5));
        _defaultUnlitMaterial->setLit(false);
        endEditCP  (_defaultUnlitMaterial);

        addRefCP(_defaultUnlitMaterial);
    }
    
    return _defaultUnlitMaterial;
}

NodePtr osg::makePlane	(	Real32	xsize,
		Real32	ysize,
		UInt16	hor,
		UInt16	vert
	)

MakePlane creates a plane in the x/y plane. It spans the [-xsize /2,xsize /2]x [-ysize /2,ysize/2] area and is subdivided into hor * vert quads.

Definition at line 124 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::Node::create(), osg::endEditCP(), osg::makePlaneGeo(), and osg::NullFC.

Referenced by osg::DisplayCalibration::createCMViewports().

{
    GeometryPtr pGeo = makePlaneGeo(xsize, ysize, hor, vert);
 
    if(pGeo == NullFC)
    {
        return NullFC;
    }
    
    NodePtr node = Node::create();

    beginEditCP  (node);
    node->setCore(pGeo);
    endEditCP    (node);

    return node;
}

GeometryPtr osg::makePlaneGeo	(	Real32	xsize,
		Real32	ysize,
		UInt16	hor,
		UInt16	vert
	)

Create the Geometry Core for used by osg::makePlane.

Definition at line 146 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::getDefaultMaterial(), osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::NullFC, and SWARNING.

Referenced by osg::makePlane().

{
    if(! hor || ! vert)
    {
        SWARNING << "makePlane: illegal parameters hor=" << hor << ", vert="
                 << vert << std::endl;
        return NullFC;
    }
    
    GeoPositions3fPtr    pnts  = GeoPositions3f::create();
    GeoNormals3fPtr      norms = GeoNormals3f::create();
    GeoTexCoords2fPtr    tex   = GeoTexCoords2f::create();
    GeoIndicesUI32Ptr    index = GeoIndicesUI32::create();   
    GeoPLengthsUI32Ptr   lens  = GeoPLengthsUI32::create();  
    GeoPTypesUI8Ptr      types = GeoPTypesUI8::create();     
    
    UInt16 x,y;
    Real32 xstep,ystep;
    xstep=xsize / hor;
    ystep=ysize / vert;

    // calc the vertices

    GeoPositions3f::StoredFieldType  * p  = pnts->editFieldPtr();
    GeoNormals3f::StoredFieldType    * n  = norms->editFieldPtr();
    GeoTexCoords2f::StoredFieldType  * tx = tex->editFieldPtr();

    beginEditCP(pnts);
    beginEditCP(norms);
    beginEditCP(tex);
    
    for(y = 0; y <= vert; y++)
    {
        for(x = 0; x <= hor; x++)
        {
            p->push_back(Pnt3f(x * xstep - xsize / 2, y * ystep - ysize / 2, 0));
            n->push_back(Vec3f(0, 0, 1));
            tx->push_back(Vec2f(x / Real32(hor), y / Real32(vert)));
        }
    }

    endEditCP(pnts);
    endEditCP(norms);
    endEditCP(tex);

    // create the faces
    
    GeoIndicesUI32::StoredFieldType    * i = index->editFieldPtr();
    GeoPLengthsUI32::StoredFieldType   * l = lens->editFieldPtr();
    GeoPTypesUI8::StoredFieldType      * t = types->editFieldPtr();

    beginEditCP(index);
    beginEditCP(lens);
    beginEditCP(types);

    for(y = 0; y < vert; y++)
    {
        t->push_back(GL_TRIANGLE_STRIP);
        l->push_back(2 * (hor + 1));
        
        for(x = 0; x <= hor; x++)
        {
            i->push_back((y + 1) * (hor + 1) + x);
            i->push_back( y      * (hor + 1) + x);
        }
    }

    endEditCP(index);
    endEditCP(lens);
    endEditCP(types);
    
    // create the geometry
    
    GeometryPtr geo = Geometry::create();

    beginEditCP(geo);
    geo->setMaterial(getDefaultMaterial());
    geo->setPositions(pnts);
    geo->setNormals(norms);
    geo->setTexCoords(tex);
    geo->setIndices(index);
    geo->editMFIndexMapping()->push_back(Geometry::MapPosition | 
                                         Geometry::MapNormal   |
                                         Geometry::MapTexCoords);
    geo->setTypes(types);
    geo->setLengths(lens);
    endEditCP(geo);
    
    return geo;
}

NodePtr osg::makeCone	(	Real32	height,
		Real32	botradius,
		UInt16	sides,
		bool	doSide,
		bool	doBottom
	)

MakeCone creates a cone. It's center sits in the origin of the x/z plane. It's radius is radius and the base is subdivided into sides parts.

Each part of the cone (bottom cap, sides) can be enabled or disabled.

Definition at line 246 of file OSGSimpleGeometry.cpp.

References osg::makeConicalFrustum().

{
    return makeConicalFrustum(height, 
                              0, 
                              botradius, 
                              sides, 
                              doSide, 
                              false, 
                              doBottom);
}

GeometryPtr osg::makeConeGeo	(	Real32	height,
		Real32	botradius,
		UInt16	sides,
		bool	doSide,
		bool	doBottom
	)

Create the Geometry Core for used by osg::makeCone.

Definition at line 265 of file OSGSimpleGeometry.cpp.

References osg::makeConicalFrustumGeo().

Referenced by osg::VRMLGeometryObjectDesc::endNode().

{
    return makeConicalFrustumGeo(height, 
                                 0, 
                                 botradius, 
                                 sides, 
                                 doSide, 
                                 false, 
                                 doBottom);
}

NodePtr osg::makeCylinder	(	Real32	height,
		Real32	radius,
		UInt16	sides,
		bool	doSide,
		bool	doTop,
		bool	doBottom
	)

MakeCylinder creates a cylinder. It's center sits in the origin of the x/z plane. It's radius is radius and the base is subdivided into sides parts.

Each part of the cylinder (top cap, bottom cap, sides) can be enabled or disabled.

Definition at line 290 of file OSGSimpleGeometry.cpp.

References osg::makeConicalFrustum().

{
    return makeConicalFrustum(height, 
                              radius, 
                              radius, 
                              sides, 
                              doSide, 
                              doTop, 
                              doBottom);
}

GeometryPtr osg::makeCylinderGeo	(	Real32	height,
		Real32	radius,
		UInt16	sides,
		bool	doSide,
		bool	doTop,
		bool	doBottom
	)

Create the Geometry Core for used by osg::makeCylinder.

Definition at line 310 of file OSGSimpleGeometry.cpp.

References osg::makeConicalFrustumGeo().

Referenced by osg::VRMLGeometryObjectDesc::endNode().

{
    return makeConicalFrustumGeo(height, 
                                 radius, 
                                 radius, 
                                 sides, 
                                 doSide, 
                                 doTop, 
                                 doBottom);
}

NodePtr osg::makeConicalFrustum	(	Real32	height,
		Real32	topradius,
		Real32	botradius,
		UInt16	sides,
		bool	doSide,
		bool	doTop,
		bool	doBottom
	)

MakeConicalFrustum creates a conical frustum. It's center sits in the origin of the x/z plane. It's height is height and the base is subdivided into sides parts. The top radius is topradius, the bottom radius botradius.

Each part of the frustum (top cap, bottom cap, sides) can be enabled or disabled. Caps forradius 0 are automatically disabled.

Definition at line 338 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::Node::create(), osg::endEditCP(), osg::makeConicalFrustumGeo(), and osg::NullFC.

Referenced by osg::makeCone(), and osg::makeCylinder().

{
    GeometryPtr pGeo = makeConicalFrustumGeo(height, 
                                             topradius, 
                                             botradius,
                                             sides, 
                                             doSide, 
                                             doTop, 
                                             doBottom);

    if(pGeo == NullFC)
    {
        return NullFC;
    }
    
    NodePtr node = Node::create();

    beginEditCP  (node);
    node->setCore(pGeo);
    endEditCP    (node);

    return node;
}

GeometryPtr osg::makeConicalFrustumGeo	(	Real32	height,
		Real32	topradius,
		Real32	botradius,
		UInt16	sides,
		bool	doSide,
		bool	doTop,
		bool	doBottom
	)

Create the Geometry Core for used by osg::makeConicalFrustum.

Definition at line 372 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::getDefaultMaterial(), osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::NullFC, osg::osgcos(), osg::osgsin(), osg::osgsqrt(), osg::Pi, and SWARNING.

Referenced by osg::makeConeGeo(), osg::makeConicalFrustum(), and osg::makeCylinderGeo().

{
    if(height <= 0 || topradius < 0 || botradius < 0 || sides < 3)
    {
        SWARNING << "makeConicalFrustum: illegal parameters height=" << height 
                 << ", topradius=" << topradius 
                 << ", botradius=" << botradius 
                 << ", sides=" << sides 
                 << std::endl;
        return NullFC;
    }
    
    GeoPositions3fPtr   pnts  = GeoPositions3f::create();
    GeoNormals3fPtr     norms = GeoNormals3f::create();
    GeoTexCoords2fPtr   tex   = GeoTexCoords2f::create();
    GeoIndicesUI32Ptr   index = GeoIndicesUI32::create();   
    GeoPLengthsUI32Ptr  lens  = GeoPLengthsUI32::create();  
    GeoPTypesUI8Ptr     types = GeoPTypesUI8::create();     
    
    Int16  j;
    Real32 delta = 2.f * Pi / sides;
    Real32 beta, x, z;
    Real32 incl = (botradius - topradius) / height;
    Real32 nlen = 1.f / osgsqrt(1 + incl * incl);
    
    // vertices

    GeoPositions3f::StoredFieldType     * p  = pnts->editFieldPtr();
    GeoNormals3f::StoredFieldType       * n  = norms->editFieldPtr();
    GeoTexCoords2f::StoredFieldType     * tx = tex->editFieldPtr();

    // faces
    
    GeoIndicesUI32::StoredFieldType     * i  = index->editFieldPtr();
    GeoPLengthsUI32::StoredFieldType    * l  = lens->editFieldPtr();
    GeoPTypesUI8::StoredFieldType       * t  = types->editFieldPtr();

    // 
    
    beginEditCP(pnts);
    beginEditCP(norms);
    beginEditCP(tex);

    beginEditCP(index);
    beginEditCP(lens);
    beginEditCP(types);
    
    if(doSide)
    {
        UInt32 baseindex = p->size();
        
        for(j = 0; j <= sides; j++)
        {
            beta = j * delta;
            x    =  osgsin(beta);
            z    = -osgcos(beta);         

            p->push_back(Pnt3f(x * topradius, height/2, z * topradius));
            n->push_back(Vec3f(x/nlen, incl/nlen, z/nlen));
            tx->push_back(Vec2f(1.f - j / Real32(sides), 1));
        }
        
        for(j = 0; j <= sides; j++)
        {
            beta = j * delta;
            x    =  osgsin(beta);
            z    = -osgcos(beta);         

            p->push_back(Pnt3f(x * botradius, -height/2, z * botradius));
            n->push_back(Vec3f(x/nlen, incl/nlen, z/nlen));
            tx->push_back(Vec2f(1.f - j / Real32(sides), 0));
        }

        t->push_back(GL_TRIANGLE_STRIP);
        l->push_back(2 * (sides + 1));

        for(j = 0; j <= sides; j++) 
        {
                i->push_back(baseindex + sides + 1 + j);
                i->push_back(baseindex + j);
        }
    }
    
    if(doTop && topradius > 0)
    {
        UInt32 baseindex = p->size();
        
        // need to duplicate the points fornow, as we don't have multi-index geo yet
        
        for(j = sides - 1; j >= 0; j--)
        {
            beta = j * delta;
            x    =  topradius * osgsin(beta);
            z    = -topradius * osgcos(beta);        

            p->push_back(Pnt3f(x, height/2, z));
            n->push_back(Vec3f(0, 1, 0));
            tx->push_back(Vec2f(x / topradius / 2 + .5f, -z / topradius / 2 + .5f));
        }

        t->push_back(GL_POLYGON);
        l->push_back(sides);

        for(j = 0; j < sides; j++) 
        {
            i->push_back(baseindex + j);
        }
    }
    
    if(doBottom && botradius > 0 )
    {
        UInt32 baseindex = p->size();
        
        // need to duplicate the points fornow, as we don't have multi-index geo yet
        
        for(j = sides - 1; j >= 0; j--)
        {
            beta = j * delta;
            x    =  botradius * osgsin(beta);
            z    = -botradius * osgcos(beta);      

            p->push_back(Pnt3f(x, -height/2, z));
            n->push_back(Vec3f(0, -1, 0));
            tx->push_back(Vec2f(x / botradius / 2 + .5f, z / botradius / 2 + .5f));
        }

        t->push_back(GL_POLYGON);
        l->push_back(sides);

        for(j = 0; j < sides; j++) 
        {
            i->push_back(baseindex + sides - 1 - j);
        }
    }
    
    endEditCP(pnts);
    endEditCP(norms);
    endEditCP(tex);
    
    endEditCP(index);
    endEditCP(lens);
    endEditCP(types);

    // create the geometry
    
    GeometryPtr geo = Geometry::create();

    beginEditCP(geo);
    geo->setMaterial(getDefaultMaterial());
    geo->setPositions(pnts);
    geo->setNormals(norms);
    geo->editMFIndexMapping()->push_back(Geometry::MapPosition | 
                                         Geometry::MapNormal   |
                                         Geometry::MapTexCoords);
    geo->setTexCoords(tex);
    geo->setIndices(index);
    geo->setTypes(types);
    geo->setLengths(lens);
    endEditCP(geo);

    return geo;
}

NodePtr osg::makeTorus	(	Real32	innerRadius,
		Real32	outerRadius,
		UInt16	sides,
		UInt16	rings
	)

MakeTorus creates a torus in the x/y plane. Sides are the number of subdivisions forthe inner radius, rings forthe outer.

Definition at line 547 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::Node::create(), osg::endEditCP(), osg::makeTorusGeo(), and osg::NullFC.

{
    GeometryPtr pGeo = makeTorusGeo(innerRadius, outerRadius, sides, rings);
 
    if(pGeo == NullFC)
    {
        return NullFC;
    }
    
    NodePtr node = Node::create();

    beginEditCP  (node);
    node->setCore(pGeo);
    endEditCP    (node);

    return node;
}

GeometryPtr osg::makeTorusGeo	(	Real32	innerRadius,
		Real32	outerRadius,
		UInt16	sides,
		UInt16	rings
	)

Create the Geometry Core for used by osg::makeTorus.

Definition at line 570 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::getDefaultMaterial(), osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::NullFC, osg::osgcos(), osg::osgsin(), osg::Pi, and SWARNING.

Referenced by osg::makeTorus().

{
    if(innerRadius <= 0 || outerRadius <= 0 || sides < 3 || rings < 3)
    {
        SWARNING << "makeTorus: illegal parameters innerRadius=" << innerRadius 
                 << ", outerRadius=" << outerRadius 
                 << ", sides=" << sides 
                 << ", rings=" << rings 
                 << std::endl;
        return NullFC;
    }
    
    GeoPositions3fPtr   pnts  = GeoPositions3f::create();
    GeoNormals3fPtr     norms = GeoNormals3f::create();
    GeoTexCoords2fPtr   tex   = GeoTexCoords2f::create();
    GeoIndicesUI32Ptr   index = GeoIndicesUI32::create();   
    GeoPLengthsUI32Ptr  lens  = GeoPLengthsUI32::create();  
    GeoPTypesUI8Ptr     types = GeoPTypesUI8::create();     
    
    UInt16 a, b;
    Real32 theta, phi;
    Real32 cosTheta, sinTheta;
    Real32 ringDelta, sideDelta;

    // calc the vertices

    GeoPositions3f::StoredFieldType   * p  = pnts->editFieldPtr();
    GeoNormals3f::StoredFieldType     * n  = norms->editFieldPtr();
    GeoTexCoords2f::StoredFieldType   * tx = tex->editFieldPtr();

    beginEditCP(pnts);
    beginEditCP(norms);
    beginEditCP(tex);
    
    ringDelta = 2.f * Pi / rings;
    sideDelta = 2.f * Pi / sides;

    for(a = 0, theta = 0.0; a <= rings; a++, theta += ringDelta) 
    {
        cosTheta = osgcos(theta);
        sinTheta = osgsin(theta);

        for(b = 0, phi = 0; b <= sides; b++, phi += sideDelta) 
        {
            GLfloat cosPhi, sinPhi, dist;

            cosPhi = osgcos(phi);
            sinPhi = osgsin(phi);
            dist   = outerRadius + innerRadius * cosPhi;

            n->push_back(Vec3f(cosTheta * cosPhi, 
                              -sinTheta * cosPhi, 
                              sinPhi));
            p->push_back(Pnt3f(cosTheta * dist, 
                              -sinTheta * dist, 
                              innerRadius * sinPhi));
            tx->push_back(Vec2f(- a / Real32(rings), b / Real32(sides)));
        }
    }   

    endEditCP(pnts);
    endEditCP(norms);
    endEditCP(tex);

    // create the faces
    
    GeoIndicesUI32::StoredFieldType  * i = index->editFieldPtr();
    GeoPLengthsUI32::StoredFieldType * l = lens->editFieldPtr();
    GeoPTypesUI8::StoredFieldType    * t = types->editFieldPtr();

    beginEditCP(index);
    beginEditCP(lens);
    beginEditCP(types);

    for(a = 0; a < sides; a++) 
    {
        t->push_back(GL_TRIANGLE_STRIP);
        l->push_back((rings + 1) * 2);
        
        for(b = 0; b <= rings; b++)
        {
            i->push_back(b * (sides+1) + a);
            i->push_back(b * (sides+1) + a + 1);
        }
    }

    endEditCP(index);
    endEditCP(lens);
    endEditCP(types);

    // create the geometry
    
    GeometryPtr geo = Geometry::create();

    beginEditCP(geo);
    geo->setMaterial(getDefaultMaterial());
    geo->setPositions(pnts);
    geo->setNormals(norms);
    geo->editMFIndexMapping()->push_back(Geometry::MapPosition | 
                                         Geometry::MapNormal   |
                                         Geometry::MapTexCoords);
    geo->setTexCoords(tex);
    geo->setIndices(index);
    geo->setTypes(types);
    geo->setLengths(lens);
    endEditCP(geo);
    
    return geo;
}

NodePtr osg::makeSphere	(	UInt16	depth,
		Real32	radius
	)

MakeSphere creates a sphere centered in the origin. It is created by recursive subdivision of an icosahedron, with depth giving the number of subdivisions and radius being the radius.

Definition at line 793 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::Node::create(), osg::endEditCP(), osg::makeSphereGeo(), and osg::NullFC.

{   
    GeometryPtr pGeo = makeSphereGeo(depth, radius);

    if(pGeo == NullFC)
    {
        return NullFC;
    }

    NodePtr node = Node::create();

    beginEditCP  (node);
    node->setCore(pGeo);
    endEditCP    (node);    
        
    return node;
}

GeometryPtr osg::makeSphereGeo	(	UInt16	depth,
		Real32	radius
	)

Create the Geometry Core for used by osg::makeSphere.

Definition at line 815 of file OSGSimpleGeometry.cpp.

References osg::Vector< ValueTypeT, SizeI >::addToZero(), osg::beginEditCP(), calcTexS(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::Eps, osg::getDefaultMaterial(), osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::TransformationMatrix< ValueTypeT >::mult(), osg::Vector< ValueTypeT, SizeI >::normalize(), osg::osgabs(), osg::osgacos(), osg::osgpow(), osg::Pi, osg::TransformationMatrix< ValueTypeT >::setTransform(), setVecLen(), and subdivideTriangle().

Referenced by osg::makeSphere().

{
    const Real32 X = .525731112119133606;
    const Real32 Z = .850650808352039932;
    const Real32 HalfPi = 1.570796326794897;

    GeoPositions3fPtr   pnts  = GeoPositions3f::create();
    GeoNormals3fPtr     norms = GeoNormals3f::create();
    GeoTexCoords2fPtr   tex   = GeoTexCoords2f::create();
    GeoIndicesUI32Ptr   index = GeoIndicesUI32::create();   
    GeoPLengthsPtr      lens  = GeoPLengthsUI32::create();  
    GeoPTypesPtr        types = GeoPTypesUI8::create();     
    UInt32              j,z;
   
    Vec3f v[12] = { Vec3f(-X, 0.,  Z),
                    Vec3f( X, 0.,  Z),
                    Vec3f(-X, 0., -Z),
                    Vec3f( X, 0., -Z),
                    Vec3f(0.,  Z,  X),
                    Vec3f(0.,  Z, -X),
                    Vec3f(0., -Z,  X),
                    Vec3f(0., -Z, -X),
                    Vec3f( Z,  X, 0.),
                    Vec3f(-Z,  X, 0.),
                    Vec3f( Z, -X, 0.),
                    Vec3f(-Z, -X, 0.)  };

    Quaternion q(Vec3f(0,1,0), osgacos(Z) + HalfPi);
    Matrix mat;

    mat.setTransform(q);

    for (j=0; j<12; j++)
        mat.mult(v[j], v[j]);
                
    Int32 tr[20][3] = { {1,4,0},  {4,9,0},  {4,5,9},  {8,5,4},  {1,8,4},
                        {1,10,8}, {10,3,8}, {8,3,5},  {3,2,5},  {3,7,2},
                        {3,10,7}, {10,6,7}, {6,11,7}, {6,0,11}, {6,1,0},
                        {10,1,6}, {11,0,9}, {2,11,9}, {5,2,9},  {11,2,7} };                  
                
    GeoPositions3f::StoredFieldType     * p = pnts->editFieldPtr();
    GeoNormals3f::StoredFieldType       * n = norms->editFieldPtr();
    GeoTexCoords2f::StoredFieldType    * tx = tex->editFieldPtr();
    GeoIndicesUI32::StoredFieldType     * i = index->editFieldPtr();

    beginEditCP(pnts);
    beginEditCP(norms);
    beginEditCP(tex);
    beginEditCP(index);
    beginEditCP(lens);
    beginEditCP(types);
    
    // initial sizing to prevent reallocation halfway through
    UInt32 estimatedSize = UInt32(osgpow(4.f, Real32(depth)) * 20.f);

    p->reserve (estimatedSize);
    n->reserve (estimatedSize);
    tx->reserve(estimatedSize);
    i->reserve (estimatedSize);
    
    // add the initial points to the fields     
    for (j=0; j<12; j++) 
    {
        Vec3f pnt = v[j];
        Vec3f norm = v[j];
        
        setVecLen(pnt, radius);
        norm.normalize();
        
        p->push_back(pnt.addToZero());
        n->push_back(norm);

        Vec2f texCoord;

        // Theta -> v
        texCoord[1] = (Pi - osgacos(norm[1])) / Pi;

        // Phi -> u
        texCoord[0] = calcTexS(norm, texCoord[1]);

        tx->push_back(texCoord);
    }
    
    // subdivide the triangles
    z=12;
    for(j=0; j<20; j++) 
    {
        subdivideTriangle(tr[j][0], tr[j][1], tr[j][2], 
                          depth, p, n, tx, i, z, radius);
    }

    types->push_back(GL_TRIANGLES);
    lens->push_back(i->size()/2);
    
    endEditCP(pnts);
    endEditCP(norms);
    endEditCP(tex);
    endEditCP(index);
    endEditCP(lens);
    endEditCP(types);
    
    // create the geometry
    GeometryPtr geo = Geometry::create();

    beginEditCP(geo);
    
    geo->setMaterial(getDefaultMaterial());
    geo->setPositions(pnts);
    geo->setNormals(norms);
    geo->editMFIndexMapping()->push_back(Geometry::MapPosition |
                                         Geometry::MapNormal);
    geo->editMFIndexMapping()->push_back(Geometry::MapTexCoords);
    geo->setTexCoords(tex);
    geo->setIndices(index);
    geo->setTypes(types);
    geo->setLengths(lens);

    endEditCP(geo);

    // now check triangles: after having created all vertices,
    // make sure, that border vertices, intersecting the x=0 plane
    // in the negative halfspace of the z=0 plane, have duplicate 
    // texture coordinates (with tex.s=1 for triangles with x>=0)
    beginEditCP(geo);
    
    beginEditCP(tex);
    beginEditCP(index);

    for (TriangleIterator ti = geo->beginTriangles();
                          ti != geo->endTriangles(); ++ti)
    {
        Vec3f q[3];
        q[0] = ti.getNormal(0);
        q[1] = ti.getNormal(1);
        q[2] = ti.getNormal(2);

        // check if one triangle point lies on this border
        if  ( (osgabs(q[0][0]) <= 0.01 && q[0][2] <= Eps) ||
              (osgabs(q[1][0]) <= 0.01 && q[1][2] <= Eps) ||
              (osgabs(q[2][0]) <= 0.01 && q[2][2] <= Eps) )
        {
            for (UInt16 i=0; i<3; i++)
            {
                Vec3f norm(q[i]);

                if (osgabs(norm[0]) <= Eps && norm[2] <= Eps)
                {
                    //Real32 theta = (Pi - osgacos(norm[1])) / Pi;
                    Real32 theta = ti.getTexCoords(i).y();

                    // triangle lies completely in positive halfspace of x=0 plane
                    if ( !(q[0][0] <= -Eps || q[1][0] <= -Eps || q[2][0] <= -Eps) )
                    {
                        Vec2f texCoord(1, theta);

                        if ( osgabs(osgabs(norm[1]) - 1) <= Eps )
                            texCoord[0] = 0.5;
    
                        tex->push_back(texCoord);
    
                        index->setValue( tex->size() - 1, ti.getIndexIndex(i) + 1 );
                    }
                    else
                    {
                        Vec2f texCoord(0, theta);

                        if ( osgabs(osgabs(norm[1]) - 1) <= Eps )
                            texCoord[0] = 0.5;
    
                        tex->push_back(texCoord);
    
                        index->setValue( tex->size() - 1, ti.getIndexIndex(i) + 1 );
                    }
                }
            }
        }
    }
    
    endEditCP(tex);
    endEditCP(index);
    
    endEditCP(geo);

    return geo;
}

NodePtr osg::makeLatLongSphere	(	UInt16	latres,
		UInt16	longres,
		Real32	radius
	)

MakeLatLongSphere creates a sphere in the origin and divided in latitude and longitude. radius is the radius of the sphere, latres and longres are the number of subdivisions along the latitudes and longitudes.

Definition at line 1008 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::Node::create(), osg::endEditCP(), osg::makeLatLongSphereGeo(), and osg::NullFC.

{
    GeometryPtr pGeo = makeLatLongSphereGeo(latres, longres, radius);
 
    if(pGeo == NullFC)
    {
        return NullFC;
    }
    
    NodePtr node = Node::create();

    beginEditCP  (node);
    node->setCore(pGeo);
    endEditCP    (node);

    return node;
}

GeometryPtr osg::makeLatLongSphereGeo	(	UInt16	latres,
		UInt16	longres,
		Real32	radius
	)

Create the Geometry Core for used by osg::makeLatLongSphere.

Definition at line 1030 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::getDefaultMaterial(), osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::NullFC, osg::osgcos(), osg::osgsin(), osg::Pi, and SWARNING.

Referenced by osg::VRMLGeometryObjectDesc::endNode(), and osg::makeLatLongSphere().

{
    if(radius <= 0 || latres < 4 || longres < 4)
    {
        SWARNING << "makeLatLongSphere: illegal parameters "
                 << "latres=" << latres 
                 << ", longres=" << longres 
                 << ", radius=" << radius 
                 << std::endl;
        return NullFC;
    }
    
    GeoPositions3fPtr   pnts  = GeoPositions3f::create();
    GeoNormals3fPtr     norms = GeoNormals3f::create();
    GeoTexCoords2fPtr   tex   = GeoTexCoords2f::create();
    GeoIndicesUI32Ptr   index = GeoIndicesUI32::create();   
    GeoPLengthsUI32Ptr  lens  = GeoPLengthsUI32::create();  
    GeoPTypesUI8Ptr     types = GeoPTypesUI8::create();     
    
    UInt16 a, b;
    Real32 theta, phi;
    Real32 cosTheta, sinTheta;
    Real32 latDelta, longDelta;

    // calc the vertices

    GeoPositions3f::StoredFieldType   * p  = pnts->editFieldPtr();
    GeoNormals3f::StoredFieldType     * n  = norms->editFieldPtr();
    GeoTexCoords2f::StoredFieldType   * tx = tex->editFieldPtr();

    beginEditCP(pnts);
    beginEditCP(norms);
    beginEditCP(tex);
    
    latDelta  =       Pi / latres;
    longDelta = 2.f * Pi / longres;

    for(a = 0, theta = -Pi / 2; a <= latres; a++, theta += latDelta) 
    {
        cosTheta = osgcos(theta);
        sinTheta = osgsin(theta);

        for(b = 0, phi = -Pi; b <= longres; b++, phi += longDelta) 
        {
            GLfloat cosPhi, sinPhi;

            cosPhi = osgcos(phi);
            sinPhi = osgsin(phi);
 
            n->push_back(Vec3f( cosTheta * sinPhi, 
                               sinTheta,
                               cosTheta * cosPhi));
            p->push_back(Pnt3f( cosTheta * sinPhi * radius, 
                               sinTheta          * radius, 
                               cosTheta * cosPhi * radius));
            tx->push_back(Vec2f(b / Real32(longres), 
                                a / Real32(latres)));
        }
    }   

    endEditCP(pnts);
    endEditCP(norms);
    endEditCP(tex);

    // create the faces
    
    GeoIndicesUI32::StoredFieldType  * i = index->editFieldPtr();
    GeoPLengthsUI32::StoredFieldType * l = lens->editFieldPtr();
    GeoPTypesUI8::StoredFieldType    * t = types->editFieldPtr();

    beginEditCP(index);
    beginEditCP(lens);
    beginEditCP(types);

    for(a = 0; a < longres; a++) 
    {
        t->push_back(GL_TRIANGLE_STRIP);
        l->push_back((latres + 1) * 2);
        
        for(b = 0; b <= latres; b++)
        {
            i->push_back(b * (longres+1) + a);
            i->push_back(b * (longres+1) + a + 1);
        }
    }

    endEditCP(index);
    endEditCP(lens);
    endEditCP(types);

    // create the geometry
    
    GeometryPtr geo = Geometry::create();

    beginEditCP(geo);
    geo->setMaterial(getDefaultMaterial());
    geo->setPositions(pnts);
    geo->setNormals(norms);
    geo->editMFIndexMapping()->push_back(Geometry::MapPosition | 
                                         Geometry::MapNormal   |
                                         Geometry::MapTexCoords);
    geo->setTexCoords(tex);
    geo->setIndices(index);
    geo->setTypes(types);
    geo->setLengths(lens);
    endEditCP(geo);
    
    return geo;
}

NodePtr osg::makeBox	(	Real32	xsize,
		Real32	ysize,
		Real32	zsize,
		UInt16	hor,
		UInt16	vert,
		UInt16	depth
	)

MakeBox creates a box around the origin. It spans the [-xsize /2,xsize /2]x [-ysize /2,ysize/2]x[-zsize /2,zsize/2] volume and is subdivided into hor * vert * depth quads.

Definition at line 1149 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::Node::create(), osg::endEditCP(), osg::makeBoxGeo(), and osg::NullFC.

{
    GeometryPtr pGeo = makeBoxGeo(xsize, ysize, zsize, hor, vert, depth);

    if(pGeo == NullFC)
    {
        return NullFC;
    }

    NodePtr node = Node::create();

    beginEditCP  (node);
    node->setCore(pGeo);
    endEditCP    (node);
    
    return node;
}

GeometryPtr osg::makeBoxGeo	(	Real32	xsize,
		Real32	ysize,
		Real32	zsize,
		UInt16	hor,
		UInt16	vert,
		UInt16	depth
	)

Create the Geometry Core for used by osg::makeBox.

Definition at line 1173 of file OSGSimpleGeometry.cpp.

References osg::beginEditCP(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::endEditCP(), osg::getDefaultMaterial(), osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::NullFC, and SWARNING.

Referenced by osg::VRMLGeometryObjectDesc::endNode(), and osg::makeBox().

{
    if(! hor || ! vert || ! depth)
    {
        SWARNING << "makeBox: illegal parameters hor=" << hor << ", vert="
                 << vert << ", depth=" << depth << std::endl;
        return NullFC;
    }
    
    GeoPositions3fPtr    pnts  = GeoPositions3f::create();
    GeoNormals3fPtr         norms = GeoNormals3f::create();
    GeoTexCoords2fPtr   tex   = GeoTexCoords2f::create();
    GeoIndicesUI32Ptr       index = GeoIndicesUI32::create();   
    GeoPLengthsUI32Ptr  lens  = GeoPLengthsUI32::create();  
    GeoPTypesUI8Ptr         types = GeoPTypesUI8::create();     
    
    UInt16 x,y,pl;
    Vec3f size(xsize,  ysize,  zsize);
    Vec3f step(xsize / hor, ysize / vert, zsize / depth);
    Vec3f res(hor,  vert,  depth);

    // calc the vertices

    GeoPositions3f::StoredFieldType  * p = pnts->editFieldPtr();
    GeoNormals3f::StoredFieldType    * n = norms->editFieldPtr();
    GeoTexCoords2f::StoredFieldType * tx = tex->editFieldPtr();

    beginEditCP(pnts);
    beginEditCP(norms);
    beginEditCP(tex);
    
    static int inds[6][2] =  { {0,1}, {0,1}, {2,1}, {2,1}, {0,2}, {0,2} };
    static int signs[6][2] = { {1,1}, {-1,1}, {-1,1}, {1,1}, {1,-1}, {1,1} };
    static int asigns[6] = { 1, -1, 1, -1, 1, -1 };
    
    for(pl = 0; pl < 6; pl++)
    {
        UInt16 axis = 3 - inds[pl][0] - inds[pl][1];
        
        for(y = 0; y <= res[inds[pl][1]] ; y++)
        {
            for(x = 0; x <= res[inds[pl][0]]; x++)
            {                       
                Pnt3f pnt;
                pnt[ inds[pl][0] ] = (x * step[inds[pl][0]] - size[inds[pl][0]] / 2) * 
                                        signs[pl][0];
                pnt[ inds[pl][1] ] = (y * step[inds[pl][1]] - size[inds[pl][1]] / 2) * 
                                        signs[pl][1];
                pnt[ axis ] = size[ axis ] * asigns[ pl ] / 2;
                p->push_back(pnt);
                
                Vec3f norm(0, 0, 0);
                norm[ axis ] = Real32(asigns[ pl ]);
                n->push_back(norm);
                tx->push_back(Vec2f(x / Real32(res[inds[pl][0]]), 
                                    y / Real32(res[inds[pl][1]])));
            }
        }
    }
    
    endEditCP(pnts);
    endEditCP(norms);
    endEditCP(tex);

    // create the faces
    
    GeoIndicesUI32::StoredFieldType     * i = index->editFieldPtr();
    GeoPLengthsUI32::StoredFieldType * l = lens->editFieldPtr();
    GeoPTypesUI8::StoredFieldType    * t = types->editFieldPtr();

    beginEditCP(index);
    beginEditCP(lens);
    beginEditCP(types);

    UInt32 basepoint = 0;
    
    for(pl = 0; pl < 6; pl++)
    {
        for(y = 0; y < res[inds[pl][1]]; y++)
        {
            UInt16 h = UInt16(res[inds[pl][0]]);
            
            t->push_back(GL_TRIANGLE_STRIP);
            l->push_back(2 * (h + 1));
            
            for(x = 0; x <= h; x++)
            {
                i->push_back(basepoint + (y + 1) * (h + 1) + x);
                i->push_back(basepoint +  y      * (h + 1) + x);
            }
        }
        basepoint += UInt32((res[inds[pl][0]] + 1.f) * 
                            (res[inds[pl][1]] + 1.f) );
    }
    
    endEditCP(index);
    endEditCP(lens);
    endEditCP(types);
    
    // create the geometry
    
    GeometryPtr geo = Geometry::create();

    beginEditCP(geo);
    geo->setMaterial(getDefaultMaterial());
    geo->setPositions(pnts);
    geo->setNormals(norms);
    geo->editMFIndexMapping()->push_back(Geometry::MapPosition | 
                                         Geometry::MapNormal |
                                         Geometry::MapTexCoords);
    geo->setTexCoords(tex);
    geo->setIndices(index);
    geo->setTypes(types);
    geo->setLengths(lens);
    endEditCP(geo);

    return geo;
}

---

Variable Documentation

SimpleMaterialPtr _defaultMaterial [static]

Stores the default material used by the Simple Geometry.

Definition at line 64 of file OSGSimpleGeometry.cpp.

SimpleMaterialPtr _defaultUnlitMaterial [static]

Stores the default unlit material.

Definition at line 93 of file OSGSimpleGeometry.cpp.