osg::ExtrusionSurface Class Reference

Encapsulates the data of an X3D extrusion surface Not intended to be directly used. Use construction functions makeExtrusion and makeExtrusionGeo instead.

#include <OSGExtrusionGeometry.h>

List of all members.

Public Member Functions
Constructors
*	ExtrusionSurface (const std::vector< Pnt2f > &crossSection, const std::vector< Quaternion > &orientation, const std::vector< Vec2f > &scale, const std::vector< Pnt3f > &spine, Real32 creaseAngle=0.f, bool beginCap=true, bool endCap=true, bool ccw=true, bool convex=true, bool buildNormal=true, bool buildTexCoord=true)
	Constructor initializing an extrusion surface.
Access
*GeometryPtr	createGeometry (UInt32 nSubDivisions)
	Creates a multi-indexed Geometry representing the extrusion surface Invoked by the construction function makeExtrusionGeo and makeExtrusion.
Private Types
typedef std::vector< Pnt3f >::const_iterator	Pnt3fConstIt
typedef std::vector< Matrix >::const_iterator	MatrixConstIt
typedef std::pair< Pnt3fConstIt, Pnt3fConstIt >	Pnt3fConstItPair
typedef std::vector< std::vector< Vertex > >	VertexGrid
typedef std::map< Pnt3f, UInt32, vecless< Pnt3f > >	PositionMap
typedef std::map< Vec3f, UInt32, vecless< Vec3f > >	NormalMap
typedef std::map< Vec2f, UInt32, vecless< Vec2f > >	TexCoordMap
Private Member Functions
	ExtrusionSurface (const ExtrusionSurface &source)
	prohibit default function (move to 'public' if needed)
void	operator= (const ExtrusionSurface &source)
	prohibit default function (move to 'public' if needed)
void	calcXAxes (void)
void	calcYAxes (void)
void	calcZAxes (void)
void	calcTransforms (void)
void	calcSweepSurfacePositions (void)
void	calcSweepSurfaceFaceNormals (void)
void	calcSweepSurfaceTexCoords (void)
void	determineTopology (void)
void	initGrid (void)
bool	verifyInput (void)
void	refineCrossSection (UInt32 nTimes)
void	refineOrientation (UInt32 nTimes)
void	refineScale (UInt32 nTimes)
void	refineSpine (UInt32 nTimes)
void	storeConvexCap (UInt32 spineIndex, bool invertNormal, GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeSweepSurfaceWithNormals (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeSweepSurfaceWithoutNormals (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeMaps (GeoPositions3fPtr positionsPtr, GeoNormals3fPtr normalsPtr, GeoTexCoords2fPtr texCoordsPtr)
void	storeVertex (const Vertex &vertex, GeoIndicesUI32Ptr indicesPtr)
void	storePrimitive (GLenum type, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
template<typename PType>
UInt32	store (PType property, std::map< PType, UInt32, vecless< PType > > &propertyIndexMap)
template<typename PType>
void	store (const PType property, std::map< PType, UInt32, vecless< PType > > &propertyIndexMap, GeoIndicesUI32Ptr indicesPtr)
Pnt3fConstItPair	getPrevAndNextIt (const Pnt3fConstIt &pIt)
Vec3f	calcNonUnitYAxis (const Pnt3fConstIt &pIt)
Vec3f	calcNonUnitZAxis (const Pnt3fConstIt &pIt)
Vec3f	calcXAxis (const MatrixConstIt &pIt)
Vec3f	calcTriangleFaceNormal (const Pnt3f &a, const Pnt3f &b, const Pnt3f &c)
Vec3f	calcQuadFaceNormal (const Pnt3f &a, const Pnt3f &b, const Pnt3f &c, const Pnt3f &d)
void	calcVertexNormal (Vertex *vertexPtr, UInt32 faceIndex)
bool	isLeft (const Pnt2f &a, const Pnt2f &b)
Real32	computeMinYAbs (const std::vector< Pnt2f > &contour, Real32 alpha)
Real32	calcBetterRotationAngle (const std::vector< Pnt2f > &contour, UInt32 nAngles)
bool	calcOptimizedContour (const std::vector< Pnt2f > &contour, const Pnt2f &point, std::vector< Pnt2f > *optimizedContour)
Int32	calcWindingNumber (const std::vector< Pnt2f > &contour, const Pnt2f &point)
void	storeFaceNormalGeo (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
void	storeVertexNormalGeo (GeoIndicesUI32Ptr indicesPtr, GeoPLengthsUI32Ptr lensPtr, GeoPTypesUI8Ptr typesPtr)
Constructors
*	ExtrusionSurface (void)
	prohibit default function (move to 'public' if needed)
Private Attributes
std::vector< Pnt2f >	_crossSection
std::vector< Quaternion >	_orientation
std::vector< Vec2f >	_scale
std::vector< Pnt3f >	_spine
Real32	_creaseAngle
bool	_beginCap
bool	_endCap
bool	_ccw
bool	_convex
bool	_crossSectionClosed
bool	_spineClosed
bool	_spineCollinear
bool	_revolutionSurface
bool	_createNormals
bool	_createTexCoords
std::vector< Matrix >	_transform
VertexGrid	_grid
PositionMap	_posMap
NormalMap	_normalMap
TexCoordMap	_texCoordMap
UInt32	_vertexCount
UInt32	_totalVertexCount
UInt32	_primitiveCount
Classes
struct	vecless
struct	Vertex

---

Detailed Description

Definition at line 140 of file OSGExtrusionGeometry.h.

---

Member Typedef Documentation

typedef std::vector<Pnt3f>::const_iterator osg::ExtrusionSurface::Pnt3fConstIt [private]

Definition at line 249 of file OSGExtrusionGeometry.h.

typedef std::vector<Matrix>::const_iterator osg::ExtrusionSurface::MatrixConstIt [private]

Definition at line 250 of file OSGExtrusionGeometry.h.

typedef std::pair<Pnt3fConstIt, Pnt3fConstIt> osg::ExtrusionSurface::Pnt3fConstItPair [private]

Definition at line 251 of file OSGExtrusionGeometry.h.

typedef std::vector< std::vector< Vertex > > osg::ExtrusionSurface::VertexGrid [private]

Definition at line 253 of file OSGExtrusionGeometry.h.

typedef std::map<Pnt3f, UInt32, vecless<Pnt3f> > osg::ExtrusionSurface::PositionMap [private]

Definition at line 255 of file OSGExtrusionGeometry.h.

typedef std::map<Vec3f, UInt32, vecless<Vec3f> > osg::ExtrusionSurface::NormalMap [private]

Definition at line 256 of file OSGExtrusionGeometry.h.

typedef std::map<Vec2f, UInt32, vecless<Vec2f> > osg::ExtrusionSurface::TexCoordMap [private]

Definition at line 257 of file OSGExtrusionGeometry.h.

---

Constructor & Destructor Documentation

ExtrusionSurface::ExtrusionSurface (  const std::vector< Pnt2f > &  crossSection, const std::vector< Quaternion > &  orientation, const std::vector< Vec2f > &  scale, const std::vector< Pnt3f > &  spine, Real32  creaseAngle = 0.f, bool  beginCap = true, bool  endCap = true, bool  ccw = true, bool  convex = true, bool  buildNormal = true, bool  buildTexCoord = true )

Parameters: crossSection  The cross-section of the sweep surface orientation  The orientation rotating the cross-section out of the XZ-plane scale  The scale values scaling the cross-section spine  The spine curve along which the cross-section is extruded creaseAngle  Determines when normals are smoothed between adjacent quads beginCap  Determines whether a begin cap is to created endCap  Determines whether an end cap is to be created ccw  Determines the ordering of the primitive vertices with respect to the generated normals convex  Determines whether the cross-section is convex buildNormal  Determines whether normals are calculated buildTexCoord  Determines whether texture coordinates are created Definition at line 125 of file OSGExtrusionGeometry.cpp. References _crossSection, _orientation, _scale, _spine, osg::DEF_CROSS_SECTION, osg::DEF_N_CROSS_SECTION_POINTS, osg::DEF_N_ORIENTATION_PARAMS, osg::DEF_N_SCALE_PARAMS, osg::DEF_N_SPINE_POINTS, osg::DEF_ORIENTATION, osg::DEF_SCALE, osg::DEF_SPINE, and FDEBUG. : _creaseAngle(creaseAngle), _beginCap(beginCap), _endCap(endCap), _ccw(ccw), _convex(convex), _createNormals(buildNormal), _createTexCoords(buildTexCoord), _primitiveCount(0), _vertexCount(0), _totalVertexCount(0) { // initialize cross section if(!crossSection.empty()) { // copy argument _crossSection.assign(crossSection.begin(), crossSection.end()); } else { // copy default FDEBUG(("OSGExtrusion: Empty cross section. Using default.\n")); for(UInt32 i = 0; i < DEF_N_CROSS_SECTION_POINTS; i++) _crossSection.push_back(Pnt2f(DEF_CROSS_SECTION[i])); } // initialize orientations if(!orientation.empty()) { // copy argument _orientation.assign(orientation.begin(), orientation.end()); } else { // copy default FDEBUG(("OSGExtrusion: Empty orientation. Using default.\n")); for(UInt32 i = 0; i < DEF_N_ORIENTATION_PARAMS; i++) _orientation.push_back(Quaternion(Vec3f(DEF_ORIENTATION[i]), DEF_ORIENTATION[i][3])); } // initialize scale parameters if(!scale.empty()) { // copy argument _scale.assign(scale.begin(), scale.end()); } else { // copy default FDEBUG(("OSGExtrusion: Empty scale parameter. Using default.\n")); for(UInt32 i = 0; i < DEF_N_SCALE_PARAMS; i++) _scale.push_back(Vec2f(DEF_SCALE[i])); } // initialize spine if(!spine.empty()) { // copy argument _spine.assign(spine.begin(), spine.end()); } else { // copy default FDEBUG(("OSGExtrusion: Empty spine. Using default.\n")); for(UInt32 i = 0; i < DEF_N_SPINE_POINTS; i++) _spine.push_back(Pnt3f(DEF_SPINE[i])); } }

* osg::ExtrusionSurface::ExtrusionSurface (  void   )  [private]

osg::ExtrusionSurface::ExtrusionSurface (  const ExtrusionSurface &  source  )  [private]

---

Member Function Documentation

GeometryPtr ExtrusionSurface::createGeometry (  UInt32  nSubDivisions  )

Parameters: nSubDivisions  The number of subdivisions to apply Returns: A pointer to a newly created geometry containing the surface Definition at line 1477 of file OSGExtrusionGeometry.cpp. References _beginCap, _convex, _createNormals, _createTexCoords, _endCap, _normalMap, _orientation, _posMap, _primitiveCount, _spine, _texCoordMap, _totalVertexCount, osg::beginEditCP(), calcSweepSurfacePositions(), calcSweepSurfaceTexCoords(), osg::GeometryBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), determineTopology(), osg::endEditCP(), FDEBUG, FFATAL, FINFO, FWARNING, osg::GeoProperty< GeoPropertyDesc >::GeoPropDataFieldMask, osg::GeometryBase::IndexMappingFieldMask, osg::GeometryBase::IndicesFieldMask, initGrid(), osg::GeometryBase::LengthsFieldMask, osg::Geometry::MapNormal, osg::Geometry::MapPosition, osg::Geometry::MapTexCoords, osg::GeometryBase::NormalsFieldMask, osg::NullFC, osg::GeometryBase::PositionsFieldMask, refineCrossSection(), refineScale(), refineSpine(), SINFO, storeConvexCap(), storeFaceNormalGeo(), storeMaps(), storeSweepSurfaceWithNormals(), storeSweepSurfaceWithoutNormals(), storeVertexNormalGeo(), osg::GeometryBase::TexCoordsFieldMask, osg::GeometryBase::TypesFieldMask, and verifyInput(). Referenced by osg::makeExtrusionGeo(). { // do some sanity checks on and determines the topology // of the _spine and _crossSection member fields if(!verifyInput()) { FWARNING(("OSGExtrusion:createGeometry: Invalid input. Returning NullFC\n")); return NullFC; } // initialize topology flags (i.e spine/_crossSection closure) determineTopology(); // optionally subdivide input data if(nSubdivs > 0) { refineCrossSection(nSubdivs); if(_orientation.size() == 1) { refineSpine(nSubdivs); refineScale(nSubdivs); } else // more than 1 orientation { // It'd be necessary to refine the orientations in order to get // a consistent result, but this is not implemented yet. FINFO(("OSGExtrusion:createGeometry: Too many orientations. Not refining along spine\n")); } } // allocate vertex grid structure initGrid(); calcSweepSurfacePositions(); if(_createTexCoords) { calcSweepSurfaceTexCoords(); } // create opensg geometry field containers GeoPositions3fPtr posPtr = GeoPositions3f::create(); GeoPLengthsUI32Ptr lensPtr = GeoPLengthsUI32::create(); GeoIndicesUI32Ptr indicesPtr = GeoIndicesUI32::create(); GeoPTypesUI8Ptr typesPtr = GeoPTypesUI8::create(); GeoNormals3fPtr normalsPtr = NullFC; GeoTexCoords2fPtr texPtr = NullFC; if(_createNormals) normalsPtr = GeoNormals3f::create(); if(_createTexCoords) texPtr = GeoTexCoords2f::create(); beginEditCP(indicesPtr, GeoIndicesUI32::GeoPropDataFieldMask); beginEditCP(lensPtr, GeoPLengthsUI32::GeoPropDataFieldMask); beginEditCP(typesPtr, GeoPTypesUI8::GeoPropDataFieldMask); if(_createNormals) { // store sweep surface as triangle strips with vertex normals storeSweepSurfaceWithNormals(indicesPtr, lensPtr, typesPtr); } else { // store sweep surface as triangle strips without vertex normals storeSweepSurfaceWithoutNormals(indicesPtr, lensPtr, typesPtr); } if(_convex) { // calculate and store caps as triangle fans if(_beginCap) { FDEBUG(("OSGExtrusion:createGeometry: Creating begin cap\n")); storeConvexCap(0, // spine section 0 true, // flip normal indicesPtr, lensPtr, typesPtr); } if(_endCap) { FDEBUG(("OSGExtrusion:createGeometry: Creating end cap\n")); storeConvexCap(_spine.size() - 1, // last spine section false, // don't flip normal indicesPtr, lensPtr, typesPtr); } } else // non-convex case { FFATAL(("OSGExtrusion:createGeometry: Support for non-convex caps not implemented\n")); } #ifdef DEBUG_VERTEX_NORMALS // add surface normals for debugging purposes storeVertexNormalGeo(indicesPtr, lensPtr, typesPtr); #endif #ifdef DEBUG_FACE_NORMALS // add sweep surface face normals for debugging purposes storeFaceNormalGeo(indicesPtr, lensPtr, typesPtr); #endif endEditCP(indicesPtr, GeoIndicesUI32::GeoPropDataFieldMask); endEditCP(lensPtr, GeoPLengthsUI32::GeoPropDataFieldMask); endEditCP(typesPtr, GeoPTypesUI8::GeoPropDataFieldMask); // store the shared vertex data into the vertex data field containers storeMaps(posPtr, normalsPtr, texPtr); // create a new OpenSG geometry GeometryPtr geoPtr = Geometry::create(); beginEditCP(geoPtr, Geometry::TypesFieldMask | Geometry::LengthsFieldMask | Geometry::IndicesFieldMask | Geometry::IndexMappingFieldMask | Geometry::PositionsFieldMask | Geometry::NormalsFieldMask | Geometry::TexCoordsFieldMask ); // The interleaved multi-index blocks have one of the following // layouts (depending on _createNormals and _createTexCoords): // // 1. (Position) // 2. (Position, Normal) // 3. (Position, TexCoord) // 4. (Position, Normal, TexCoord) geoPtr->getIndexMapping().push_back(Geometry::MapPosition); if(_createNormals) geoPtr->getIndexMapping().push_back(Geometry::MapNormal); if(_createTexCoords) geoPtr->getIndexMapping().push_back(Geometry::MapTexCoords); // set primitive data field containers geoPtr->setLengths(lensPtr); geoPtr->setIndices(indicesPtr); geoPtr->setTypes(typesPtr); // set vertex data field containers geoPtr->setPositions(posPtr); geoPtr->setNormals(normalsPtr); geoPtr->setTexCoords(texPtr); endEditCP(geoPtr, Geometry::TypesFieldMask | Geometry::LengthsFieldMask | Geometry::IndicesFieldMask | Geometry::IndexMappingFieldMask | Geometry::PositionsFieldMask | Geometry::NormalsFieldMask | Geometry::TexCoordsFieldMask ); SINFO << "OSGExtrusion:createGeometry: Stats: (" << _primitiveCount << '/' << _totalVertexCount << '/' << _posMap.size() << '/' << _normalMap.size() << '/' << _texCoordMap.size() << ')' << "(Prims/Verts/Pos/Norms/TexCoords)" << std::endl; return geoPtr; }

void osg::ExtrusionSurface::operator= (  const ExtrusionSurface &  source  )  [private]

void ExtrusionSurface::calcXAxes (  void   )  [inline, private]

Calculates the X-Axes of the CP to SCP transforms Definition at line 331 of file OSGExtrusionGeometry.cpp. References _revolutionSurface, _spineCollinear, _transform, and calcXAxis(). Referenced by calcTransforms(). { std::vector<Matrix>::iterator tIt = _transform.begin(); // Either of the two cases below implies the cross product of // the y- and the z-axis vanish (and so do all x-axes) if(!_spineCollinear && !_revolutionSurface) { for(; tIt != _transform.end(); ++tIt) { Vec3f xAxis = calcXAxis(tIt); (*tIt)[0].setValue(xAxis); } } else { (*tIt)[0].setValue(Vec3f(0.f, 0.f, 0.f)); } }

void ExtrusionSurface::calcYAxes (  void   )  [inline, private]

Calculates the Y-Axes of the CP to SCP transforms Definition at line 361 of file OSGExtrusionGeometry.cpp. References _revolutionSurface, _spine, _transform, calcNonUnitYAxis(), osg::Eps, FDEBUG, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize(). Referenced by calcTransforms(). { bool yAxisDefined = false; std::vector<Pnt3f>::const_iterator spineIt = _spine.begin(); std::vector<Matrix>::iterator tIt = _transform.begin(); for(; spineIt != _spine.end(); ++spineIt, ++tIt) { Vec3f yAxis = calcNonUnitYAxis(spineIt); if(yAxis.length() > Eps) // we have found a valid tangent { yAxis.normalize(); if(!yAxisDefined) { FDEBUG(("OSGExtrusion:calcYAxes: yAxis is defined\n")); yAxisDefined = true; // assign found y-axis to all transforms // up to and including the current one std::vector<Matrix>::iterator yIt; for(yIt = _transform.begin(); yIt != (tIt + 1); ++yIt) (*yIt)[1].setValue(yAxis); } else { // assign found y-axis to the current transform only (*tIt)[1].setValue(yAxis); } } else if(yAxisDefined) { // reuse y-axis determined during last step (*tIt)[1] = (*(tIt - 1))[1]; } } // all spine points coincided => surface of revolution _revolutionSurface = !yAxisDefined; }

void ExtrusionSurface::calcZAxes (  void   )  [inline, private]

Calculates the Z-Axes of the CP to SCP transforms Definition at line 410 of file OSGExtrusionGeometry.cpp. References _spine, _spineCollinear, _transform, calcNonUnitZAxis(), osg::VectorInterface< ValueTypeT, StorageInterfaceT >::dot(), osg::Eps, FDEBUG, osg::VectorInterface< ValueTypeT, StorageInterfaceT >::length(), osg::PointInterface< ValueTypeT, StorageInterfaceT >::negate(), and osg::VectorInterface< ValueTypeT, StorageInterfaceT >::normalize(). Referenced by calcTransforms(). { bool zAxisDefined = false; std::vector<Pnt3f>::const_iterator spineIt = _spine.begin(); std::vector<Matrix>::iterator tIt = _transform.begin(); for(; spineIt != _spine.end(); ++spineIt, ++tIt) { Vec3f zAxis = calcNonUnitZAxis(spineIt); if(zAxis.length() > Eps) { zAxis.normalize(); if(!zAxisDefined) { FDEBUG(("OSGExtrusion:calcZAxes: zAxis is defined\n")); zAxisDefined = true; // set the current z-Axis for the current transform (*tIt)[2].setValue(zAxis); // assign found z-axis to all previous transforms std::vector<Matrix>::iterator zIt; for(zIt = _transform.begin(); zIt != tIt; ++zIt) { (*zIt)[2].setValue(zAxis); } } else // assign found z-axis to this basis _only_ { (*tIt)[2].setValue(zAxis); // as the zAxis is defined tIt - 1 contains a valid value Vec3f prevZAxis((*(tIt - 1))[2][0], (*(tIt - 1))[2][1], (*(tIt - 1))[2][2]); // check whether the z-axis needs to be flipped if(prevZAxis.dot(zAxis) + Eps < 0.f) { FDEBUG(("OSGExtrusion:calcZAxes: Flipping z-axis\n")); zAxis.negate(); } // assign zAxis to current transform (*tIt)[2].setValue(zAxis); } } else if(zAxisDefined) { // reuse previous value (*tIt)[2] = (*(tIt - 1))[2]; } } // end for // All cross products vanished => spine has no non-collinear part // and is thus composed of collinear parts and revolutions only _spineCollinear = !zAxisDefined; }

void ExtrusionSurface::calcTransforms (  void   )  [private]

Calculates the affine transformations from CP to SCP Definition at line 480 of file OSGExtrusionGeometry.cpp. References _orientation, _revolutionSurface, _scale, _spine, _spineCollinear, _transform, calcXAxes(), calcYAxes(), calcZAxes(), FDEBUG, osg::QuaternionBase< ValueTypeT >::getValue(), osg::TransformationMatrix< ValueTypeT >::multLeft(), and osg::QuaternionBase< ValueTypeT >::setValue(). Referenced by calcSweepSurfacePositions(). { _transform.clear(); // initialize the transformations with Id _transform.resize(_spine.size()); /* X3D Spec: * The SCP is computed by first computing its Y-axis and Z-axis, then * taking the cross product of these to determine the X-axis. These three * axes are then used to determine the rotation value needed to rotate the * Y=0 plane to the SCP. This results in a plane that is the approximate * tangent of the spine at each point, as shown in Figure 13.5. */ calcZAxes(); // sets bool _spineCollinear calcYAxes(); // sets bool _revolutionSurface // We need to make a difference between surfaces having at least // one non-trivial collinear part in their spine and surfaces created // by pure revolution of the crossection. if(_revolutionSurface) { _spineCollinear = false; } calcXAxes(); // uses _spineCollinear and _revolutionSurface /* X3D Spec: * * If the entire spine is collinear, the SCP is computed by finding the * rotation of a vector along the positive Y-axis (v1) to the vector formed * by the spine points (v2). The Y=0 plane is then rotated by this value. * * If two points are coincident, they both have the same SCP. If each point * has a different orientation value, then the surface is constructed by * connecting edges of the cross-sections as normal. This is useful in * creating revolved surfaces. */ Matrix rotation; // m = Id and thus ok for revolution case if(_spineCollinear && !_revolutionSurface) { // calculate the rotation that rotates the y unit vector to the // direction of the spine. Vec3f v1(0.f, 1.f, 0.f); Vec3f v2(_transform[0][1]); Quaternion q; q.setValue(v1, v2); q.getValue(rotation); } std::vector<Matrix>::iterator tIt = _transform.begin(); std::vector<Pnt3f>::const_iterator spineIt = _spine.begin(); std::vector<Vec2f>::const_iterator scaleIt = _scale.begin(); std::vector<Quaternion>::const_iterator rotIt = _orientation.begin(); // calculate an affine transformation for the cross-section at // each spine point for(; spineIt != _spine.end(); ++spineIt, ++tIt) { // special cases if(_spineCollinear || _revolutionSurface) { // defines the x,y and z-axes in this case *tIt = rotation; } // setup transform of the CP Matrix cSPlaneTransform; // Scale the x- and z-axes cSPlaneTransform[0] *= (*scaleIt)[0]; cSPlaneTransform[2] *= (*scaleIt)[1]; // apply orientation Matrix orientationMatrix; rotIt->getValue(orientationMatrix); cSPlaneTransform.multLeft(orientationMatrix); tIt->mult(cSPlaneTransform); // affine translation to the spine point tIt->setTranslate(*spineIt); // The affine transformation *tIt should now // // 1. scale the CP // 2. apply the orientation to the CP // 2. translate the origin to spine[i] // // in exactly this order. /* X3D Spec quotation: * * If the number of scale or orientation values is greater than the * number of spine points, the excess values are ignored. If they * contain one value, it is applied at all spine points. The * results are undefined if the number of scale or orientation * values is greater than one but less than the number of spine * points. The scale values shall be positive. */ // always use last available value if(rotIt + 1 != _orientation.end()) { ++rotIt; } if(scaleIt + 1 != _scale.end()) { ++scaleIt; } } FDEBUG(("OSGExtrusion:calcTransforms: spine collinear: %s\n", (_spineCollinear ? "true" : "false"))); FDEBUG(("OSGExtrusion:calcTransforms: revolution surface: %s\n", (_revolutionSurface ? "true" : "false"))); }

void ExtrusionSurface::calcSweepSurfacePositions (  void   )  [private]

Calculates the positions of the sweep surface and stores them in the _grid Definition at line 624 of file OSGExtrusionGeometry.cpp. References _crossSection, _grid, _posMap, _spine, _transform, calcTransforms(), osg::Eps, FDEBUG, FFATAL, FWARNING, initGrid(), p, and SWARNING. Referenced by createGeometry(). { FDEBUG(("OSGExtrusion:calcSweepSurfacePositions: Calculation vertex positions\n")); if(_grid.size() < _spine.size()) { FFATAL(("OSGExtrusion:calcSweepSurfacePositions: Grid not initialized\n")); return; } _posMap.clear(); // compute transformation matrices calcTransforms(); if(_grid.size() < _spine.size()) // grid not yet or incorrectly initialized { initGrid(); } std::vector<Matrix>::iterator transIt = _transform.begin(); VertexGrid::iterator gridRowIt = _grid.begin(); // iterate over the spine points for(Int32 i = 0; i < _spine.size(); i++, ++gridRowIt) { if(transIt->det3() < Eps) // degenerate transform { FWARNING(("OSGExtrusion:calcSurfacePositions: Degenerate transformation matrix\n")); SWARNING << "Degenerate transform[" << i << "]:\n " << *transIt << std::endl; } std::vector<Vertex>::iterator gridColIt = gridRowIt->begin(); std::vector<Pnt2f>::iterator crossIt; // iterate over the cross-section curve for(crossIt = _crossSection.begin(); crossIt != _crossSection.end(); ++crossIt, ++gridColIt) { Pnt3f p = Pnt3f((*crossIt)[0], 0.f, (*crossIt)[1]); // apply "CP to SCP"-transform transIt->multMatrixPnt(p, gridColIt->position); } // always use last defined transformation matrix if(transIt + 1 != _transform.end()) { ++transIt; } } }

void ExtrusionSurface::calcSweepSurfaceFaceNormals (  void   )  [private]

Calculates the face normals of the sweep surface and stores them in the _grid Definition at line 748 of file OSGExtrusionGeometry.cpp. References _crossSection, _crossSectionClosed, _grid, _spine, _spineClosed, calcQuadFaceNormal(), FDEBUG, and FFATAL. Referenced by storeSweepSurfaceWithNormals(). { FDEBUG(("OSGExtrusion:calcSweepSurfaceFaceNormals: Calculating sweep surface face normals\n")); if(_grid.size() < _spine.size()) { FFATAL(("OSGExtrusion:calcSweepSurfaceFaceNormals: Grid not initialized\n")); return; } // calculate face normals for(UInt32 i = 0; i < _spine.size(); ++i) { UInt32 iPrev, iNext; // determine adjacent row indices if(_spineClosed) { // first point == last point iPrev = (i != 0) ? i - 1 : _spine.size() - 2; iNext = (i != _spine.size() - 1) ? i + 1 : 1; } else { iPrev = (i != 0) ? i - 1 : 0; iNext = (i != _spine.size() - 1) ? i + 1 : i; } for(UInt32 j = 0; j < _crossSection.size(); ++j) { Vec3f n; UInt32 jPrev, jNext; // determine adjacent column indices if(_crossSectionClosed) { // first point == last point jPrev = (j != 0) ? j - 1 : _crossSection.size() - 2; jNext = (j != _crossSection.size() - 1) ? j + 1 : 1; } else { jPrev = (j != 0) ? j - 1 : 0; jNext = (j != _crossSection.size() - 1) ? j + 1 : j; } // upper right face normal (1st quadrant) _grid[i][j].adjFaceNormals[0] = calcQuadFaceNormal(_grid[i][j].position, _grid[i][jNext].position, _grid[iNext][jNext].position, _grid[iNext][j].position); // upper left face normal (2nd quadrant) _grid[i][j].adjFaceNormals[1] = calcQuadFaceNormal(_grid[i][j].position, _grid[iNext][j].position, _grid[iNext][jPrev].position, _grid[i][jPrev].position); // lower left face normal (3nd quadrant) _grid[i][j].adjFaceNormals[2] = calcQuadFaceNormal(_grid[i][j].position, _grid[i][jPrev].position, _grid[iPrev][jPrev].position, _grid[iPrev][j].position); // lower right face normal (4th quadrant) _grid[i][j].adjFaceNormals[3] = calcQuadFaceNormal(_grid[i][j].position, _grid[iPrev][j].position, _grid[iPrev][jNext].position, _grid[i][jNext].position); } } }

void ExtrusionSurface::calcSweepSurfaceTexCoords (  void   )  [private]

Definition at line 686 of file OSGExtrusionGeometry.cpp. References _crossSection, _grid, _spine, _texCoordMap, osg::Eps, FDEBUG, and FFATAL.