osg::OFFSceneFileType Class Reference
[File Input/Output]

OSGOFFSceneFileType.

#include <OSGOFFSceneFileType.h>

Inheritance diagram for osg::OFFSceneFileType:

List of all members.

Public Types
typedef std::vector < FieldContainerPtr >	FCPtrStore
Flags
enum	{ OSG_READ_SUPPORTED = 1, OSG_WRITE_SUPPORTED = 2 }
Public Member Functions
Destructors
virtual	~OFFSceneFileType (void)
Get
virtual const Char8 *	getName (void) const
Read
virtual NodePtr	read (std::istream &is, const Char8 *fileNameOrExtension) const
Set
void	setOptions (const Char8 *options)
Get
virtual std::list< IDString > &	suffixList (void)
bool	doOverride (void)
UInt32	getOverridePriority (void)
UInt32	getFlags (void)
const Char8 *	getOptions (void)
Read
virtual NodePtr	readFile (const Char8 *fileName) const
Write
virtual bool	write (const NodePtr &node, std::ostream &os, const Char8 *fileNameOrExtension) const
virtual bool	writeFile (const NodePtr &node, const Char8 *fileName) const
Debug
void	print (void)
Static Public Member Functions
Class Get
static OFFSceneFileType &	the (void)
Protected Member Functions
Constructors
	OFFSceneFileType (const Char8 *suffixArray[], UInt16 suffixByteCount, bool override, UInt32 overridePriority, UInt32 flags)
	OFFSceneFileType (const OFFSceneFileType &obj)
Protected Attributes
Member
std::list< IDString >	_suffixList
bool	_override
UInt32	_overridePriority
UInt32	_flags
std::string	_options
Static Protected Attributes
Member
static const Char8 *	_suffixA [] = { "off" }
static OFFSceneFileType	_the
Private Types
typedef SceneFileType	Inherited
Private Member Functions
void	operator= (const OFFSceneFileType &source)
	prohibit default function (move to 'public' if needed)

---

Detailed Description

Definition at line 54 of file OSGOFFSceneFileType.h.

---

Member Typedef Documentation

typedef SceneFileType osg::OFFSceneFileType::Inherited [private]

Definition at line 115 of file OSGOFFSceneFileType.h.

typedef std::vector<FieldContainerPtr> osg::SceneFileType::FCPtrStore [inherited]

Reimplemented in osg::OSGSceneFileType, and osg::VRMLSceneFileType.

Definition at line 65 of file OSGSceneFileType.h.

---

Member Enumeration Documentation

anonymous enum [inherited]

Enumerator:

OSG_READ_SUPPORTED
OSG_WRITE_SUPPORTED

Definition at line 78 of file OSGSceneFileType.h.

    {
        OSG_READ_SUPPORTED = 1,
        OSG_WRITE_SUPPORTED = 2
    };

---

Constructor & Destructor Documentation

OFFSceneFileType::~OFFSceneFileType

(

void

)

[virtual]

Definition at line 506 of file OSGOFFSceneFileType.cpp.

{
    return;
}

OFFSceneFileType::OFFSceneFileType	(	const Char8 *	suffixArray[],
		UInt16	suffixByteCount,
		bool	override,
		UInt32	overridePriority,
		UInt32	flags
	)			[protected]

constructors & destructors

Definition at line 445 of file OSGOFFSceneFileType.cpp.

                                                 :
    SceneFileType(suffixArray, suffixByteCount,
                  override, overridePriority, flags)
{
}

OFFSceneFileType::OFFSceneFileType

(

const OFFSceneFileType &

obj

)

[protected]

constructors & destructors

Definition at line 474 of file OSGOFFSceneFileType.cpp.

                                                              :
    SceneFileType(obj)
{
    return;
}

---

Member Function Documentation

OFFSceneFileType & OFFSceneFileType::the

(

void

)

[static]

Definition at line 500 of file OSGOFFSceneFileType.cpp.

References _the.

{
    return _the;
}

const Char8 * OFFSceneFileType::getName

(

void

)

const [virtual]

Implements osg::SceneFileType.

Definition at line 512 of file OSGOFFSceneFileType.cpp.

{
    return "Geomview Geometry";
}

NodePtr OFFSceneFileType::read	(	std::istream &	is,
		const Char8 *	fileNameOrExtension
	)			const [virtual]

Reimplemented from osg::SceneFileType.

Definition at line 120 of file OSGOFFSceneFileType.cpp.

References osg::FieldBits::AllFields, osg::beginEditCP(), osg::calcVertexNormals(), osg::Node::CoreFieldMask, osg::SimpleMaterialBase::create(), osg::GeoProperty< GeoPropertyDesc >::create(), osg::GeometryBase::create(), osg::Node::create(), osg::createSharedIndex(), osg::endEditCP(), FDEBUG, FFATAL, FNOTICE, FWARNING, osg::NullFC, osg::Color4< ValueTypeT >::setValuesRGBA(), osg::SceneFileHandler::the(), and osg::SceneFileHandler::updateReadProgress().

{
    typedef std::vector<int> Face;

    std::vector<Face>   faceVec;

    char                head[256];
    NodePtr             root;
    GeometryPtr         geo;
    Pnt3f               point;
    Vec3f               norm;
    Color4f             color;
    Vec2f               texcoord;
    GeoPositions3fPtr   points;
    GeoIndicesUI32Ptr   index;
    GeoPLengthsPtr      lens;
    GeoPTypesPtr        type;
    GeoNormals3fPtr     norms;
    GeoColors4fPtr      colors;
    GeoTexCoords2fPtr   texcoords;
    SimpleMaterialPtr   mat;
    Int32               i, j, k, n, vN, fN, pType;
    Int32               triCount = 0, vertexCount, faceCount, edgeCount;
    Real32              x, y, z, a;
    bool                hasNormals = false, hasColors = false, hasTexCoords = false,
                        has4DimPoints = false;
    
    if(!is)
    {
        return NullFC;
    }

    is >> head >> vertexCount >> faceCount >> edgeCount;

    FDEBUG(("OFF Head/vertexCount/faceCount: %s/%d/%d\n", head,
           vertexCount, faceCount));

    if(!vertexCount || !faceCount)
    {
        return NullFC;
    }

    if(strstr(head, "ST"))
    {
        hasTexCoords = true;
    }

    if(strstr(head, "C"))
    {
        hasColors = true;
    }

    if(strstr(head, "N"))
    {
        hasNormals = true;
    }

    if(strstr(head, "4"))
    {
        has4DimPoints = true;
    }

    if(strstr(head, "nOFF"))
    {
        int ndim;
        
        is >> ndim;
        
        if(ndim != 3)
        {
            FWARNING(("OFFSceneFileType::read: nOFF with ndim != 3 not supported.\n"));
            return NullFC;
        }
    }
    
    if(has4DimPoints)
    {
         FWARNING(("OFFSceneFileType::read: 4D points not supported.\n"));
        return NullFC;       
    }
    
    
    //-------------------------------------------------------------------
    // create the OSG objects
    root = Node::create();
    geo = Geometry::create();
    points = GeoPositions3f::create();
    index = GeoIndicesUI32::create();
    lens = GeoPLengthsUI32::create();
    type = GeoPTypesUI8::create();
    mat = SimpleMaterial::create();
    if (hasNormals)
        norms = GeoNormals3f::create();
    if (hasColors)
        colors = GeoColors4f::create();
    if (hasTexCoords)
        texcoords = GeoTexCoords2f::create();

    beginEditCP(mat);
    {
        mat->setDiffuse(Color3f(0.42, 0.42, 0.52));
        mat->setSpecular(Color3f(1, 1, 1));
        mat->setShininess(20);
    }
    endEditCP(mat);

    beginEditCP(root, Node::CoreFieldMask);
    {
        root->setCore(geo);
    }
    endEditCP(root, Node::CoreFieldMask);

    beginEditCP(geo);
    {
        geo->setPositions(points);
        geo->setIndices(index);
        geo->setLengths(lens);
        geo->setTypes(type);
        geo->setMaterial(mat);
        if (hasNormals)
            geo->setNormals(norms);
        if (hasColors)
            geo->setColors(colors);
        if (hasTexCoords)
            geo->setTexCoords(texcoords);
            
    }
    endEditCP(geo);

    //-------------------------------------------------------------------
    // read/set the points
    beginEditCP(points);
    if(hasNormals)
        beginEditCP(norms);
    if(hasColors)
        beginEditCP(colors);
    if(hasTexCoords)
        beginEditCP(texcoords);
        
    {
        for(i = 0; (!is.eof()) && (i < vertexCount); i++)
        {
            SceneFileHandler::the().updateReadProgress();
            is >> x >> y >> z;
            point.setValues(Real32(x), Real32(y), Real32(z));
            points->push_back(point);
            
            if(hasNormals)
            {
                is >> x >> y >> z;
                norm.setValues(Real32(x), Real32(y), Real32(z));
                norms->push_back(norm);
            }
            
            if(hasColors)
            {
                is >> x >> y >> z >> a;
                color.setValuesRGBA(Real32(x), 
                                    Real32(y), 
                                    Real32(z), 
                                    Real32(a));
                colors->getField().push_back(color);
            }
            
            if(hasTexCoords)
            {
                is >> x >> y;
                texcoord.setValues(Real32(x), Real32(y));
                texcoords->push_back(texcoord);
            }
        }
    }
    endEditCP(points);
    if(hasNormals)
        endEditCP(norms);
    if(hasColors)
        endEditCP(colors);
    if(hasTexCoords)
        endEditCP(texcoords);

    //-------------------------------------------------------------------
    // read the faces
    // TODO; should we 'reserve' some index mem (3,4,..) ?
    faceVec.resize(faceCount);
    triCount = 0;
    for(i = 0; (!is.eof()) && (i < faceCount); i++)
    {
        is >> n;
        if(n >= 0)
        {
            triCount += n - 2;
            for(j = 0; (!is.eof()) && (j < n); j++)
            {
                is >> k;
                if((k >= 0) && (k < vertexCount))
                    faceVec[i].push_back(k);
                else
                {
                    FFATAL(("Invalid vertex index %d in face %d\n", k, i
                           ));
                }
            }
            is.ignore(1000, '\n');
        }
        else
        {
            FFATAL(("Invalid face vec num %d\n", n));
        }
    }

    //-------------------------------------------------------------------
    // set the faces
    for(i = 3; i <= 5; i++)
    {
        n = 0;
        for(j = 0; j < faceCount; j++)
        {
            fN = faceVec[j].size();
            if(fN >= 5)
                fN = 5;
            if(fN == i)
            {
                n += vN = faceVec[j].size();
                for(k = vN - 1; k >= 0; k--)
                {
                    index->getFieldPtr()->push_back(faceVec[j][k]);
                }

                if(i == 5)
                {
                    beginEditCP(lens);
                    {
                        lens->push_back(n);
                    }
                    endEditCP(lens);

                    beginEditCP(type, FieldBits::AllFields);
                    {
                        type->push_back(GL_POLYGON);
                    }
                    endEditCP(type, FieldBits::AllFields);
                }
            }
        }

        if(n)
        {
            switch(i)
            {
            case 3:
                pType = GL_TRIANGLES;
                break;
            case 4:
                pType = GL_QUADS;
                break;
            default:
                pType = 0;
                break;
            }

            if(pType)
            {
                beginEditCP(lens);
                {
                    lens->push_back(n);
                }
                endEditCP(lens);

                beginEditCP(type, FieldBits::AllFields);
                {
                    type->push_back(pType);
                }
                endEditCP(type, FieldBits::AllFields);
            }
        }
    }

    FNOTICE(("Number of triangle read: %d\n", triCount));

    createSharedIndex(geo);
    if(!hasNormals)
        calcVertexNormals(geo);

    SceneFileHandler::the().updateReadProgress(100);
    return root;
}

void osg::OFFSceneFileType::operator=

(

const OFFSceneFileType &

source

)

[private]

void SceneFileType::setOptions

(

const Char8 *

options

)

[inherited]

Definition at line 115 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_options.

Referenced by osg::SceneFileHandler::setOptions().

{
    _options = options;
}

std::list< IDString > & SceneFileType::suffixList

(

void

)

[virtual, inherited]

Definition at line 138 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_suffixList.

Referenced by osg::SceneFileHandler::addSceneFileType(), and osg::SceneFileHandler::subSceneFileType().

{
    return _suffixList;
}

bool SceneFileType::doOverride

(

void

)

[inherited]

Definition at line 145 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_override.

Referenced by osg::SceneFileHandler::addSceneFileType(), and osg::SceneFileHandler::FindOverride::operator()().

{
    return _override;
}

UInt32 SceneFileType::getOverridePriority

(

void

)

[inherited]

Definition at line 152 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_overridePriority.

Referenced by osg::SceneFileHandler::addSceneFileType(), and osg::SceneFileHandler::FindOverride::operator()().

{
    return _overridePriority;
}

UInt32 SceneFileType::getFlags

(

void

)

[inherited]

Definition at line 159 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_flags.

Referenced by osg::SceneFileHandler::getSuffixList(), and osg::SceneFileHandler::print().

{
    return _flags;
}

const Char8 * SceneFileType::getOptions

(

void

)

[inherited]

Definition at line 166 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_options.

Referenced by osg::SceneFileHandler::getOptions().

{
    return _options.c_str();
}

NodePtr SceneFileType::readFile

(

const Char8 *

fileName

)

const [virtual, inherited]

Definition at line 181 of file OSGSceneFileType.cpp.

References FWARNING, and osg::NullFC.

Referenced by osg::SceneFileHandler::read().

{
    FWARNING (("FILE INTERFACE NOT IMPLEMENTED!\n"));
    return NullFC;
}

bool SceneFileType::write	(	const NodePtr &	node,
		std::ostream &	os,
		const Char8 *	fileNameOrExtension
	)			const [virtual, inherited]

Reimplemented in osg::BINSceneFileType, osg::OBJSceneFileType, osg::OSGSceneFileType, and osg::VRMLSceneFileType.

Definition at line 188 of file OSGSceneFileType.cpp.

References FWARNING.

Referenced by osg::SceneFileHandler::write().

{
    FWARNING (("STREAM INTERFACE NOT IMPLEMENTED!\n"));
    return false;
}

bool SceneFileType::writeFile	(	const NodePtr &	node,
		const Char8 *	fileName
	)			const [virtual, inherited]

Definition at line 197 of file OSGSceneFileType.cpp.

References FWARNING.

Referenced by osg::SceneFileHandler::write().

{
    FWARNING (("FILE INTERFACE NOT IMPLEMENTED!\n"));
    return false;
}

void SceneFileType::print

(

void

)

[inherited]

Definition at line 121 of file OSGSceneFileType.cpp.

References osg::SceneFileType::_suffixList, osg::SceneFileType::getName(), osg::LOG_DEBUG, osg::osgLog(), and osg::Log::stream().

{
    std::list<IDString>::iterator sI;

    osgLog() << getName();

    if (_suffixList.empty())
        osgLog() << "NONE";
    else
        for (sI = _suffixList.begin(); sI != _suffixList.end(); sI++)
            osgLog().stream(OSG::LOG_DEBUG) << sI->str() << " ";

    osgLog() << std::endl;
}

---

Member Data Documentation

const Char8 * OFFSceneFileType::_suffixA = { "off" } [static, protected]

Definition at line 95 of file OSGOFFSceneFileType.h.

OFFSceneFileType OFFSceneFileType::_the [static, protected]

Definition at line 96 of file OSGOFFSceneFileType.h.

Referenced by the().

std::list<IDString> osg::SceneFileType::_suffixList [protected, inherited]

Definition at line 152 of file OSGSceneFileType.h.

Referenced by osg::SceneFileType::print(), osg::SceneFileType::SceneFileType(), and osg::SceneFileType::suffixList().

bool osg::SceneFileType::_override [protected, inherited]

Definition at line 154 of file OSGSceneFileType.h.

Referenced by osg::SceneFileType::doOverride().

UInt32 osg::SceneFileType::_overridePriority [protected, inherited]

Definition at line 155 of file OSGSceneFileType.h.

Referenced by osg::SceneFileType::getOverridePriority().

UInt32 osg::SceneFileType::_flags [protected, inherited]

Definition at line 156 of file OSGSceneFileType.h.

Referenced by osg::SceneFileType::getFlags().

std::string osg::SceneFileType::_options [protected, inherited]

Definition at line 158 of file OSGSceneFileType.h.

Referenced by osg::SceneFileType::getOptions(), osg::SceneFileType::setOptions(), and osg::VRMLSceneFileType::write().

---

The documentation for this class was generated from the following files:

• OSGOFFSceneFileType.h
• OSGOFFSceneFileType.cpp