VP1QtInventorUtils Class Reference

#include <VP1QtInventorUtils.h>

Collaboration diagram for VP1QtInventorUtils:

Classes
class	Imp

Static Public Member Functions
static SbColor	qcol2sbcol (const QColor &)
static QColor	sbcol2qcol (const SbColor &)
static SoNode *	createCircle (const double &radius)
static SoNode *	createEllipse (const double &radiusX, const double &radiusY, const int &numnodes=12)
static QImage	renderToImage (VP1ExaminerViewer *ra, int pixels_x, int pixels_y, bool transparent_background=false, double actualRenderedSizeFact=1.0)
static QPixmap	renderToPixmap (VP1ExaminerViewer *ra, int pixels_x, int pixels_y, bool transparent_background=false, double actualRenderedSizeFact=1.0)
static QPixmap	pixmapFromRGBFile (const QString &filename)
static QImage	imageFromRGBFile (const QString &filename)
static SoGLRenderAction::TransparencyType	getDefaultVP1TransparencyType ()
static QList< SoGLRenderAction::TransparencyType >	getAllTransparencyTypes ()
static int	transparencyTypeToInt (SoGLRenderAction::TransparencyType)
static SoGLRenderAction::TransparencyType	intToTransparencyType (int)
static QString	transparencyType2PrettyString (SoGLRenderAction::TransparencyType)
static QByteArray	serialize (const SbRotation &)
static bool	deserialize (QByteArray &, SbRotation &)
static QByteArray	serialize (const SbVec3f &)
static bool	deserialize (QByteArray &, SbVec3f &)
static QByteArray	serializeSoCameraParameters (const SoCamera &)
static bool	deserializeSoCameraParameters (QByteArray &, SoCamera &)
static QByteArray	serialiseSoMaterial (SoMaterial *)
static bool	deserialiseSoMaterial (QByteArray &, SoMaterial *&)
static bool	changePathTail (SoPath *path, SoNode *commonBranchPoint, SoNode *newtail)
static bool	writeGraphToFile (SoNode *root, const QString &filename)
static SoSeparator *	readGraphFromFile (const QString &filename)
static bool	writeGraphToVRMLFile (SoNode *root, const QString &filename)
static void	setMatColor (SoMaterial *, const double &r, const double &g, const double &b, const double &brightness=0.0, const double &transp=0.0)
static void	setMatColor (SoMaterial *, const QColor &, const double &brightness=0.0, const double &transp=0.0)
static void	getLineWidthRanges (double &min, double &max, double &granularity)
static void	getPointSizeRanges (double &min, double &max, double &granularity)
static void	setLimitsLineWidthSlider (QSlider *)
static void	setLimitsPointSizeSlider (QSlider *)
static void	setValueLineWidthSlider (QSlider *, const double &value)
static void	setValuePointSizeSlider (QSlider *, const double &value)
static double	getValueLineWidthSlider (const QSlider *)
static double	getValuePointSizeSlider (const QSlider *)
static void	ensureInitLineWidthAndPointSize (SoQtRenderArea *)

Private Member Functions
	VP1QtInventorUtils ()
	~VP1QtInventorUtils ()

Detailed Description

Definition at line 41 of file VP1QtInventorUtils.h.

Constructor & Destructor Documentation

VP1QtInventorUtils()

VP1QtInventorUtils::VP1QtInventorUtils ( )

private

Definition at line 386 of file VP1QtInventorUtils.cxx.

{
}

~VP1QtInventorUtils()

VP1QtInventorUtils::~VP1QtInventorUtils ( )

private

Definition at line 391 of file VP1QtInventorUtils.cxx.

{
}

Member Function Documentation

changePathTail()

bool VP1QtInventorUtils::changePathTail ( SoPath * path, SoNode * commonBranchPoint, SoNode * newtail )

static

Definition at line 1351 of file VP1QtInventorUtils.cxx.

{
    if (!path||!commonBranchPoint||!newtail)
        return false;
 
    SoSearchAction sa;
    sa.setInterest(SoSearchAction::FIRST);
    sa.setNode(newtail);
    sa.apply(commonBranchPoint);
    //First truncate pickedPath at d->sceneroot, then append
    //newpath to pickedPath:
    SoPath * newpath = sa.getPath();
    if (!newpath)
        return false;
    bool found(false);
    for (int i=0;i<path->getLength();++i) {
        if (path->getNode(i)==commonBranchPoint) {
            found = true;
            path->truncate(i+1);
            break;
        }
    }
    if (found)
        path->append(newpath);
    return found;
}

createCircle()

SoNode * VP1QtInventorUtils::createCircle ( const double & radius )

static

Definition at line 1285 of file VP1QtInventorUtils.cxx.

{
    SoGroup* grp = new SoGroup;
    grp->ref();
 
    SoCoordinate4 * coord = new SoCoordinate4;
    const double invsqrttwo=0.707106781186547;
 
    int icoord(0);
    coord->point.set1Value(icoord++,SbVec4f(1*radius,0,0,1));
    coord->point.set1Value(icoord++,SbVec4f(invsqrttwo*radius,invsqrttwo*radius,0,invsqrttwo));
    coord->point.set1Value(icoord++,SbVec4f(0,1*radius,0,1));
    coord->point.set1Value(icoord++,SbVec4f(-invsqrttwo*radius,invsqrttwo*radius,0,invsqrttwo));
    coord->point.set1Value(icoord++,SbVec4f(-1*radius,0,0,1));
    coord->point.set1Value(icoord++,SbVec4f(-invsqrttwo*radius,-invsqrttwo*radius,0,invsqrttwo));
    coord->point.set1Value(icoord++,SbVec4f(0,-1*radius,0,1));
    coord->point.set1Value(icoord++,SbVec4f(invsqrttwo*radius,-invsqrttwo*radius,0,invsqrttwo));
    coord->point.set1Value(icoord++,SbVec4f(1*radius,0,0,1));
 
    SoNurbsCurve * curve = new SoNurbsCurve;
    curve->numControlPoints = icoord;
 
    int iknot(0);
 
    curve->knotVector.set1Value(iknot++,0);
    curve->knotVector.set1Value(iknot++,0);
    curve->knotVector.set1Value(iknot++,0);
    curve->knotVector.set1Value(iknot++,1);
    curve->knotVector.set1Value(iknot++,1);
    curve->knotVector.set1Value(iknot++,2);
    curve->knotVector.set1Value(iknot++,2);
    curve->knotVector.set1Value(iknot++,3);
    curve->knotVector.set1Value(iknot++,3);
    curve->knotVector.set1Value(iknot++,4);
    curve->knotVector.set1Value(iknot++,4);
    curve->knotVector.set1Value(iknot++,4);
    grp->addChild(coord);
    grp->addChild(curve);
 
    grp->unrefNoDelete();
    return grp;
}

createEllipse()

SoNode * VP1QtInventorUtils::createEllipse ( const double & radiusX, const double & radiusY, const int & numnodes = 12 )

static

Definition at line 1329 of file VP1QtInventorUtils.cxx.

{
    SoVertexProperty *vertices = new SoVertexProperty();
 
    int iver(0);
    vertices->vertex.set1Value(iver++,radiusX,0.0,0.0);
    for (int i = 1; i < numnodes; i++)
    {
        vertices->vertex.set1Value(iver++,
                cos(2.0*static_cast<double>(i)*M_PI/static_cast<double>(numnodes))*radiusX,
                sin(2.0*static_cast<double>(i)*M_PI/static_cast<double>(numnodes))*radiusY,0.0);
    }
    vertices->vertex.set1Value(iver++,radiusX,0.0,0.0);
 
    SoLineSet * ellipse = new SoLineSet();
    ellipse->numVertices = iver;
    ellipse->vertexProperty = vertices;
 
    return ellipse;
}

deserialiseSoMaterial()

bool VP1QtInventorUtils::deserialiseSoMaterial ( QByteArray & ba, SoMaterial *& m )

static

Definition at line 1191 of file VP1QtInventorUtils.cxx.

{
    if (!m||m->ambientColor.getNum()!=1
            ||m->diffuseColor.getNum()!=1
            ||m->specularColor.getNum()!=1
            ||m->emissiveColor.getNum()!=1
            ||m->transparency.getNum()!=1
            ||m->shininess.getNum()!=1) {
        VP1Msg::message("VP1QtInventorUtils::deserialiseSoMaterial Error: "
                "Passed material must have exactly one value in each of the 6 fields!!");
        return false;
    }
 
    // ===> Setup stream for getting the contents of the byteArray:
    QBuffer buffer(&ba);
    buffer.open(QIODevice::ReadOnly);
    QDataStream stream(&buffer);
    if(ba.size()==106)
        stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
    //Read contents while checking for validity
    QString str; stream >> str;
    if (str!="somat_v1_begin")
        return false;
 
    QColor ambientcol;  stream >> ambientcol;
    if (!ambientcol.isValid())
        return false;
 
    QColor diffusecol;  stream >> diffusecol;
    if (!diffusecol.isValid())
        return false;
 
    QColor specularcol;  stream >> specularcol;
    if (!specularcol.isValid())
        return false;
 
    QColor emissivecol;  stream >> emissivecol;
    if (!emissivecol.isValid())
        return false;
 
    if(ba.size()==106) {
        // Single precision
        float shininess; stream >> shininess;
        if (shininess<0.0f||shininess>1.0f)
            return false;
 
        float transparency; stream >> transparency;
        if (transparency<0.0f||transparency>1.0f)
            return false;
 
        stream >> str;
        if (str!="somat_end")
            return false;
 
        buffer.close();
 
        //Apply values:
        m->ambientColor.setValue(qcol2sbcol(ambientcol));
        m->diffuseColor.setValue(qcol2sbcol(diffusecol));
        m->specularColor.setValue(qcol2sbcol(specularcol));
        m->emissiveColor.setValue(qcol2sbcol(emissivecol));
        m->shininess.setValue(shininess);
        m->transparency.setValue(transparency);
    }
    else {
        // Double precision
        double shininess; stream >> shininess;
        if (shininess<0.0||shininess>1.0)
            return false;
 
        double transparency; stream >> transparency;
        if (transparency<0.0||transparency>1.0)
            return false;
 
        stream >> str;
        if (str!="somat_end")
            return false;
 
        buffer.close();
 
        //Apply values:
        m->ambientColor.setValue(qcol2sbcol(ambientcol));
        m->diffuseColor.setValue(qcol2sbcol(diffusecol));
        m->specularColor.setValue(qcol2sbcol(specularcol));
        m->emissiveColor.setValue(qcol2sbcol(emissivecol));
        m->shininess.setValue(shininess);
        m->transparency.setValue(transparency);
    }
 
    return true;
}

deserialize() [1/2]

bool VP1QtInventorUtils::deserialize ( QByteArray & ba, SbRotation & rot )

static

Definition at line 762 of file VP1QtInventorUtils.cxx.

{
    // ===> Setup stream for getting the contents of the byteArray:
    QBuffer buffer(&ba);
    buffer.open(QIODevice::ReadOnly);
    QDataStream state(&buffer);
    if(ba.size()==16) {
        // Single precision
        state.setFloatingPointPrecision(QDataStream::SinglePrecision);
        float q0,q1,q2,q3;//quarternion components
 
        state >> q0;
        state >> q1;
        state >> q2;
        state >> q3;
 
        rot.setValue (q0,q1,q2,q3);
 
        if (VP1Msg::verbose()) {
            //Fixme: check for nan's.
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserialize SbRotation(q0,q1,q2,q3) = ("
                    +QString::number(q0)+", "+QString::number(q1)+", "
                    +QString::number(q2)+", "+QString::number(q3)+")");
        }
    }
    else {
        // Double precision
        double q0,q1,q2,q3;//quarternion components
 
        state >> q0;
        state >> q1;
        state >> q2;
        state >> q3;
 
        rot.setValue (q0,q1,q2,q3);
 
        if (VP1Msg::verbose()) {
            //Fixme: check for nan's.
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserialize SbRotation(q0,q1,q2,q3) = ("
                    +QString::number(q0)+", "+QString::number(q1)+", "
                    +QString::number(q2)+", "+QString::number(q3)+")");
        }
    }
 
    // ===> Finish up:
    buffer.close();
 
    return true;//Fixme: How to check for errors? - at least check for nan's and determinant?
}

deserialize() [2/2]

bool VP1QtInventorUtils::deserialize ( QByteArray & ba, SbVec3f & vec )

static

Definition at line 841 of file VP1QtInventorUtils.cxx.

{
    // ===> Setup stream for getting the contents of the byteArray:
    QBuffer buffer(&ba);
    buffer.open(QIODevice::ReadOnly);
    QDataStream state(&buffer);
    if(ba.size()==12) {
        // Single precision
        state.setFloatingPointPrecision(QDataStream::SinglePrecision);
        float x,y,z;
 
        state >> x;
        state >> y;
        state >> z;
 
        vec.setValue (x,y,z);
 
        if (VP1Msg::verbose()) {
            //Fixme: check for nan's.
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserialize SbVec3f(x,y,z) = ("
                    +QString::number(x)+", "+QString::number(y)+", "+QString::number(z)+")");
        }
    }
    else {
        double x,y,z;
 
        state >> x;
        state >> y;
        state >> z;
 
        vec.setValue (x,y,z);
 
        if (VP1Msg::verbose()) {
            //Fixme: check for nan's.
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserialize SbVec3f(x,y,z) = ("
                    +QString::number(x)+", "+QString::number(y)+", "+QString::number(z)+")");
        }
    }
 
    // ===> Finish up:
    buffer.close();
 
    return true;//Fixme: How to check for errors?  - at least check for nan's
 
}

deserializeSoCameraParameters()

bool VP1QtInventorUtils::deserializeSoCameraParameters ( QByteArray & ba, SoCamera & cam )

static

Definition at line 964 of file VP1QtInventorUtils.cxx.

{
    VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters start");
    if (ba==QByteArray())
        return false;
 
    // ===> Setup stream for getting the contents of the byteArray:
    QBuffer buffer(&ba);
    buffer.open(QIODevice::ReadOnly);
    QDataStream state(&buffer);
    if(ba.size()==64) {
        // Single precision
        state.setFloatingPointPrecision(QDataStream::SinglePrecision);
 
        //Orientation:
        SbRotation rot;  QByteArray ba_rot; state >> ba_rot;
        if (!deserialize(ba_rot,rot)) return false;
        //position:
        SbVec3f pos;  QByteArray ba_pos; state >> ba_pos;
        if (!deserialize(ba_pos,pos)) return false;
 
        bool save = cam.enableNotify(false);
        cam.ref();
        cam.orientation.setValue(rot);
        cam.position.setValue(pos);
        //Misc:
        float f_aspectRatio, f_nearDistance, f_farDistance, f_focalDistance;
 
        state >> f_aspectRatio; cam.aspectRatio.setValue(f_aspectRatio);
        state >> f_nearDistance; cam.nearDistance.setValue(f_nearDistance);
        state >> f_farDistance; cam.farDistance.setValue(f_farDistance);
        state >> f_focalDistance; cam.focalDistance.setValue(f_focalDistance);
        //viewport mapping:
        int viewportmap;
        state>>viewportmap;
        switch (viewportmap) {
        case 0: cam.viewportMapping.setValue(SoCamera::CROP_VIEWPORT_FILL_FRAME); break;
        case 1: cam.viewportMapping.setValue(SoCamera::CROP_VIEWPORT_LINE_FRAME);break;
        case 2: cam.viewportMapping.setValue(SoCamera::CROP_VIEWPORT_NO_FRAME);break;
        case 3: cam.viewportMapping.setValue(SoCamera::ADJUST_CAMERA);break;
        case 4: cam.viewportMapping.setValue(SoCamera::LEAVE_ALONE);break;
        //ERROR
        }
 
        bool passedcameraisperspective = cam.getTypeId().isDerivedFrom(SoPerspectiveCamera::getClassTypeId());
 
        //Camera type and specialised info:
        int camtype;
        state>>camtype;
        float f_orthopersp_heightpar(-999);
        if (camtype==0) {
            //perspective
            if (!passedcameraisperspective)
                return false;
            state >> f_orthopersp_heightpar;
            static_cast<SoPerspectiveCamera*>(&cam)->heightAngle.setValue(f_orthopersp_heightpar);
        } else if (camtype==1) {
            //ortho
            if (passedcameraisperspective)
                return false;
            state >> f_orthopersp_heightpar;
            static_cast<SoOrthographicCamera*>(&cam)->height.setValue(f_orthopersp_heightpar);
        }
 
        if (save) {
            cam.enableNotify(true);
            cam.touch();
        }
 
        // ===> Finish up:
        buffer.close();
 
        if (VP1Msg::verbose()) {
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters aspectRatio = "+QString::number(f_aspectRatio));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters nearDistance = "+QString::number(f_nearDistance));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters farDistance = "+QString::number(f_farDistance));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters focalDistance = "+QString::number(f_focalDistance));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters viewportmap = "+QString::number(viewportmap));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters camtype = "
                    +QString(camtype==0?"perspective":(camtype==1?"orthographic":"unknown")));
            if (camtype==0)
                VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters (persp) heightAngle = "
                        +QString::number(f_orthopersp_heightpar));
            if (camtype==1)
                VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters (ortho) height = "
                        +QString::number(f_orthopersp_heightpar));
 
        }
    }
    else {
        // Double precision
 
        //Orientation:
        SbRotation rot;  QByteArray ba_rot; state >> ba_rot;
        if (!deserialize(ba_rot,rot)) return false;
        //position:
        SbVec3f pos;  QByteArray ba_pos; state >> ba_pos;
        if (!deserialize(ba_pos,pos)) return false;
 
        bool save = cam.enableNotify(false);
        cam.ref();
        cam.orientation.setValue(rot);
        cam.position.setValue(pos);
        //Misc:
        double f_aspectRatio, f_nearDistance, f_farDistance, f_focalDistance;
 
        state >> f_aspectRatio; cam.aspectRatio.setValue(f_aspectRatio);
        state >> f_nearDistance; cam.nearDistance.setValue(f_nearDistance);
        state >> f_farDistance; cam.farDistance.setValue(f_farDistance);
        state >> f_focalDistance; cam.focalDistance.setValue(f_focalDistance);
        //viewport mapping:
        int viewportmap;
        state>>viewportmap;
        switch (viewportmap) {
        case 0: cam.viewportMapping.setValue(SoCamera::CROP_VIEWPORT_FILL_FRAME); break;
        case 1: cam.viewportMapping.setValue(SoCamera::CROP_VIEWPORT_LINE_FRAME);break;
        case 2: cam.viewportMapping.setValue(SoCamera::CROP_VIEWPORT_NO_FRAME);break;
        case 3: cam.viewportMapping.setValue(SoCamera::ADJUST_CAMERA);break;
        case 4: cam.viewportMapping.setValue(SoCamera::LEAVE_ALONE);break;
        //ERROR
        }
 
        bool passedcameraisperspective = cam.getTypeId().isDerivedFrom(SoPerspectiveCamera::getClassTypeId());
 
        //Camera type and specialised info:
        int camtype;
        state>>camtype;
        double f_orthopersp_heightpar(-999);
        if (camtype==0) {
            //perspective
            if (!passedcameraisperspective)
                return false;
            state >> f_orthopersp_heightpar;
            static_cast<SoPerspectiveCamera*>(&cam)->heightAngle.setValue(f_orthopersp_heightpar);
        } else if (camtype==1) {
            //ortho
            if (passedcameraisperspective)
                return false;
            state >> f_orthopersp_heightpar;
            static_cast<SoOrthographicCamera*>(&cam)->height.setValue(f_orthopersp_heightpar);
        }
 
        if (save) {
            cam.enableNotify(true);
            cam.touch();
        }
 
        // ===> Finish up:
        buffer.close();
 
        if (VP1Msg::verbose()) {
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters aspectRatio = "+QString::number(f_aspectRatio));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters nearDistance = "+QString::number(f_nearDistance));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters farDistance = "+QString::number(f_farDistance));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters focalDistance = "+QString::number(f_focalDistance));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters viewportmap = "+QString::number(viewportmap));
            VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters camtype = "
                    +QString(camtype==0?"perspective":(camtype==1?"orthographic":"unknown")));
            if (camtype==0)
                VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters (persp) heightAngle = "
                        +QString::number(f_orthopersp_heightpar));
            if (camtype==1)
                VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters (ortho) height = "
                        +QString::number(f_orthopersp_heightpar));
 
        }
    }
 
    cam.unrefNoDelete();
    VP1Msg::messageVerbose("VP1QtInventorUtils::deserializeSoCameraParameters end");
    return true;
}

ensureInitLineWidthAndPointSize()

void VP1QtInventorUtils::ensureInitLineWidthAndPointSize ( SoQtRenderArea * ra )

static

Definition at line 1521 of file VP1QtInventorUtils.cxx.

{
    if (!Imp::lineWidthAndPointSizeNeedsInit)
        return;
    Imp::lineWidthAndPointSizeNeedsInit = false;
    QWidget * w(0);
    if (!ra) {
        VP1Msg::messageVerbose("VP1QtInventorUtils WARNING: Have to create temporary renderarea for the sole "
                "purpose of getting supported line widths and point sizes!");
        w = new QWidget(0);
        ra = new VP1ExaminerViewer(w);
    }
    SbVec2f range; float granularity;
    ra->getLineWidthLimits(range, granularity);
    float a,b;
    range.getValue(a,b);
    Imp::allowedLineWidthMin = a;
    Imp::allowedLineWidthMax = b;
    Imp::allowedLineWidthGranularity = granularity;
    VP1Msg::messageVerbose("VP1QtInventorUtils Determined line widths supported by hardware (min,max,granularity) = ("
            +VP1Msg::str(a)+", "+VP1Msg::str(b)+", "+VP1Msg::str(granularity)+")");
    ra->getPointSizeLimits(range, granularity);
    range.getValue(a,b);
    Imp::allowedPointSizeMin = a;
    Imp::allowedPointSizeMax = b;
    Imp::allowedPointSizeGranularity = granularity;
    VP1Msg::messageVerbose("VP1QtInventorUtils Determined point sizes supported by hardware (min,max,granularity) = ("
            +VP1Msg::str(a)+", "+VP1Msg::str(b)+", "+VP1Msg::str(granularity)+")");
    if (w) {
        delete ra;
        delete w;
    }
    //We clip to get a more consistent behaviour across hardware (and to limit ourselves to reasonable values:
 
    if (Imp::allowedLineWidthMin<0.5)
        Imp::allowedLineWidthMin = 0.5;
    if (Imp::allowedLineWidthMax>7.0)
        Imp::allowedLineWidthMax = 7.0;
    if (Imp::allowedPointSizeMin<0.5)
        Imp::allowedPointSizeMin = 0.5;
    if (Imp::allowedPointSizeMax>12.0)
        Imp::allowedPointSizeMax = 12.0;
}

getAllTransparencyTypes()

QList< SoGLRenderAction::TransparencyType > VP1QtInventorUtils::getAllTransparencyTypes ( )

static

Definition at line 650 of file VP1QtInventorUtils.cxx.

{
    QList<SoGLRenderAction::TransparencyType> l;
    l << SoGLRenderAction::NONE
            << SoGLRenderAction::SCREEN_DOOR
            << SoGLRenderAction::ADD
            << SoGLRenderAction::DELAYED_ADD
            << SoGLRenderAction::SORTED_OBJECT_ADD
            << SoGLRenderAction::BLEND
            << SoGLRenderAction::DELAYED_BLEND
            << SoGLRenderAction::SORTED_OBJECT_BLEND
            << SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_ADD
            << SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND
            << SoGLRenderAction::SORTED_LAYERS_BLEND;
    return l;
}

getDefaultVP1TransparencyType()

SoGLRenderAction::TransparencyType VP1QtInventorUtils::getDefaultVP1TransparencyType ( )

static

Definition at line 644 of file VP1QtInventorUtils.cxx.

{
    return SoGLRenderAction::DELAYED_BLEND;
}

getLineWidthRanges()

void VP1QtInventorUtils::getLineWidthRanges ( double & min, double & max, double & granularity )

static

Definition at line 1501 of file VP1QtInventorUtils.cxx.

{
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    min = Imp::allowedLineWidthMin;
    max = Imp::allowedLineWidthMax;
    granularity = Imp::allowedLineWidthGranularity;
}

getPointSizeRanges()

void VP1QtInventorUtils::getPointSizeRanges ( double & min, double & max, double & granularity )

static

Definition at line 1511 of file VP1QtInventorUtils.cxx.

{
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    min = Imp::allowedPointSizeMin;
    max = Imp::allowedPointSizeMax;
    granularity = Imp::allowedPointSizeGranularity;
}

getValueLineWidthSlider()

double VP1QtInventorUtils::getValueLineWidthSlider ( const QSlider * slider )

static

Definition at line 1622 of file VP1QtInventorUtils.cxx.

{
    if (!slider)
        return 1.0;
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    return std::max(Imp::allowedLineWidthMin,std::min(Imp::allowedLineWidthMax,
            Imp::allowedLineWidthMin+Imp::allowedLineWidthGranularity * slider->value()));
}

getValuePointSizeSlider()

double VP1QtInventorUtils::getValuePointSizeSlider ( const QSlider * slider )

static

Definition at line 1633 of file VP1QtInventorUtils.cxx.

{
    if (!slider)
        return 1.0;
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    return std::max(Imp::allowedPointSizeMin,std::min(Imp::allowedPointSizeMax,
            Imp::allowedPointSizeMin+Imp::allowedPointSizeGranularity * slider->value()));
}

imageFromRGBFile()

QImage VP1QtInventorUtils::imageFromRGBFile ( const QString & filename )

static

Definition at line 403 of file VP1QtInventorUtils.cxx.

{
    int width = 0;
  int height = 0;
  int components = 0;
  //more realistically, limits are probably 4'096
  constexpr int maxheight(10'000);
  constexpr int maxwidth(10'000);
  auto inbounds = [](int w, int h)->bool{
    return (w>0 and w<maxwidth) and (h>0 and h<maxheight);
  };
    unsigned * imagedata = Imp::read_texture(filename.toStdString().c_str(), &width, &height, &components);
  if( not inbounds(width, height)){
    std::cout << "VP1QtInventorUtils::imageFromRGBFile - read_texture failed?" << std::endl;
    width = std::clamp(width, 0, maxwidth);
    height = std::clamp(height, 0, maxheight);
  } 
    unsigned char * data = reinterpret_cast<unsigned char*>(imagedata);
  
    QImage im(width,height, ( components <= 3 ? QImage::Format_RGB32 : QImage::Format_ARGB32 ) );
 
    int x{}, y{}, index{};
    for (; y<height; ++y) {
        for (x=0; x<width; ++x) {
            //Fixme: Does this also work for components=1,2 4??
            im.setPixel ( x, height-y-1, QColor( static_cast<int>(data[index]),static_cast<int>(data[index+1]),static_cast<int>(data[index+2]),static_cast<int>(data[index+3]) ).rgb() );
            index+=4;
        }
    }
    free(imagedata);
    return im;
}

intToTransparencyType()

SoGLRenderAction::TransparencyType VP1QtInventorUtils::intToTransparencyType ( int i )

static

Definition at line 688 of file VP1QtInventorUtils.cxx.

{
    switch (i) {
    case 0: return SoGLRenderAction::SCREEN_DOOR;
    case 1: return SoGLRenderAction::ADD;
    case 2: return SoGLRenderAction::DELAYED_ADD;
    case 3: return SoGLRenderAction::SORTED_OBJECT_ADD;
    case 4: return SoGLRenderAction::BLEND;
    case 5: return SoGLRenderAction::DELAYED_BLEND;
    case 6: return SoGLRenderAction::SORTED_OBJECT_BLEND;
    case 7: return SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_ADD;
    case 8: return SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND;
    case 9: return SoGLRenderAction::NONE;
    case 10: return SoGLRenderAction::SORTED_LAYERS_BLEND;
    default:
        VP1Msg::messageDebug("VP1QtInventorUtils::intToTransparencyType ERROR: int out of range "+VP1Msg::str(i));
        return SoGLRenderAction::DELAYED_BLEND;
    }
}

pixmapFromRGBFile()

QPixmap VP1QtInventorUtils::pixmapFromRGBFile ( const QString & filename )

static

Definition at line 396 of file VP1QtInventorUtils.cxx.

{
    return QPixmap::fromImage(imageFromRGBFile(filename));
 
}

qcol2sbcol()

SbColor VP1QtInventorUtils::qcol2sbcol ( const QColor & col )

static

Definition at line 1139 of file VP1QtInventorUtils.cxx.

{
    return SbColor( col.red()/255.0, col.green()/255.0, col.blue()/255.0 );
}

readGraphFromFile()

SoSeparator * VP1QtInventorUtils::readGraphFromFile ( const QString & filename )

static

Definition at line 1450 of file VP1QtInventorUtils.cxx.

{
    //  SoDB::init();
    SoInput in;
    if (!in.openFile(filename.toStdString().c_str()))
        return 0;
    return SoDB::readAll(&in);
}

renderToImage()

QImage VP1QtInventorUtils::renderToImage ( VP1ExaminerViewer * ra, int pixels_x, int pixels_y, bool transparent_background = false, double actualRenderedSizeFact = 1.0 )

static

Definition at line 439 of file VP1QtInventorUtils.cxx.

{
    VP1Msg::messageVerbose("VP1QtInventorUtils::renderToImage()");
 
    if (!ra)
        return QImage();
 
 
    //  transp,anti: Render two large, figure out transp, then resize (gives best result)
    //  transp     : Render two normal, then figure out transp.
    //             : Render one normal.
    //  anti       : Render one large, resize.
 
    if (actualRenderedSizeFact!=1.0&&!transparent_background) {
        return renderToImage(ra,
                static_cast<int>(pixels_x*actualRenderedSizeFact+0.5),
                static_cast<int>(pixels_y*actualRenderedSizeFact+0.5),
                false,
                1.0)
                .scaled(pixels_x,pixels_y,Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
    }
 
    if (transparent_background) {
        //Lets make it transparent. We do this by rendering with both
        //white and black background, and using the two results to figure
        //out the final result.
 
        SbColor save_bgd = ra->getBackgroundColor();
        SbBool save_redraw = ra->isAutoRedraw();
 
        ra->setAutoRedraw(false);
 
 
        QImage im_black_bgd, im_white_bgd;
        if (actualRenderedSizeFact==1.0) {
            ra->setBackgroundColor(SbColor(0.0,0.0,0.0));
            im_black_bgd = renderToImage(ra, pixels_x, pixels_y,false,1.0);
            ra->setBackgroundColor(SbColor(1.0,1.0,1.0));
            im_white_bgd = renderToImage(ra, pixels_x, pixels_y,false,1.0);
        } else {
            ra->setBackgroundColor(SbColor(0.0,0.0,0.0));
            im_black_bgd = renderToImage(ra, static_cast<int>(pixels_x*actualRenderedSizeFact+0.5), static_cast<int>(pixels_y*actualRenderedSizeFact+0.5),false,1.0);
            ra->setBackgroundColor(SbColor(1.0,1.0,1.0));
            im_white_bgd = renderToImage(ra, static_cast<int>(pixels_x*actualRenderedSizeFact+0.5), static_cast<int>(pixels_y*actualRenderedSizeFact+0.5),false,1.0);
        }
 
        ra->setBackgroundColor(save_bgd);
        ra->setAutoRedraw(save_redraw);
 
        if (actualRenderedSizeFact==1.0)
            return Imp::constructImageWithTransparentBackground(im_black_bgd, im_white_bgd);
        else
            return Imp::constructImageWithTransparentBackground(im_black_bgd, im_white_bgd)
        .scaled(pixels_x,pixels_y,Qt::IgnoreAspectRatio,Qt::SmoothTransformation);
    }
 
    // DEFAULT CALL
 
    //debug
    int off = ra->getStereoOffsetSlot();
    int typeSt = ra->getStereoTypeSlot();
    VP1Msg::messageVerbose("off: " + QString::number( off ) + " - type: " + QString::number( typeSt ) );
 
    // get the scenegraph
    SoNode *root = ra->getSceneManager()->getSceneGraph();
    VP1Msg::messageVerbose("got the scenegraph");
    //std::cout << "root: " << root << std::endl;
 
    // get the overlay scenegraph
//  SoNode *rootOverlay = ra->getOverlaySceneManager()->getSceneGraph();
    SoNode *rootOverlay = ra->getOverlaySceneGraph();
    VP1Msg::messageVerbose("got the overlay scenegraph");
    //std::cout << "overlay root: " << rootOverlay << std::endl;
 
    // set a new viewport to the preferred size
    SbViewportRegion myViewport;
    myViewport.setWindowSize(SbVec2s(pixels_x,pixels_y));
 
    QString tmppath(QDir::tempPath());
    if (!tmppath.endsWith(QDir::separator()))
        tmppath+=QDir::separator();
        tmppath += "vp1tmpfileXXXXXX.rgb";
        std::string stmppath = tmppath.toStdString();
        int tmpfd = mkstemps (stmppath.data(), 4);
        FILE* tmpf = fdopen (tmpfd, "w");
    QString tmpfile (stmppath.c_str());
 
    // declare a new renderer with the viewport created above
    SoOffscreenRenderer *myRenderer = new SoOffscreenRenderer(myViewport);
 
    //Copy settings from the render area:
    myRenderer->setBackgroundColor(ra->getBackgroundColor());
 
 
    myRenderer->setComponents(SoOffscreenRenderer::RGB_TRANSPARENCY);
    myRenderer->getGLRenderAction()->setTransparencyType(ra->getTransparencyType());
    //  myRenderer->getGLRenderAction()->addPreRenderCallback( VP1QtInventorUtils::Imp::prerendercallback_rendertoimage, 0/*userdata*/ );
 
    // Anti-Aliasing
    SbBool smoothing; int numPasses;
    ra->getAntialiasing (smoothing, numPasses);
    myRenderer->getGLRenderAction()->setSmoothing (smoothing);
    myRenderer->getGLRenderAction()->setNumPasses(numPasses);
 
    //Other things we could set:
    //  Overlay scenegraph.
 
    // render the scenegraph
    // if fails, delete the renderer and return an empty image
    if (!myRenderer->render(root)) {
        delete myRenderer;
        fclose (tmpf);
        return QImage();
    }
    VP1Msg::messageVerbose("rendered the scenegraph");
 
    // render the overlay scenegraph
    // if fails, delete the renderer and return an empty image
    if (rootOverlay) {
        bool okOver = myRenderer->render(rootOverlay);
        if ( !okOver) {
            delete myRenderer;
            fclose (tmpf);
            return QImage();
        }
        else {
            VP1Msg::messageVerbose("rendered the overlay scenegraph");
        }
    }
 
    // write the rendered image to the temp file
    // if fails, remove the temp file and return an empty image
    if (!myRenderer->writeToRGB(tmpf)) {
                fclose (tmpf);
        if (QFile::exists(tmpfile))
            QFile(tmpfile).remove();
        delete myRenderer;
        return QImage();
    }
 
        fclose (tmpf);
 
    // delete the renderer
    delete myRenderer;
 
    // get the rendered image from the temp file as a Qt QImage instance
    QImage im(imageFromRGBFile(tmpfile));
 
    // delete the temp file
    if (QFile::exists(tmpfile))
        QFile(tmpfile).remove();
 
    // return the rendered image
    return im;
}

renderToPixmap()

QPixmap VP1QtInventorUtils::renderToPixmap ( VP1ExaminerViewer * ra, int pixels_x, int pixels_y, bool transparent_background = false, double actualRenderedSizeFact = 1.0 )

static

Definition at line 598 of file VP1QtInventorUtils.cxx.

{
    return QPixmap::fromImage(renderToImage(ra, pixels_x, pixels_y, transparent_background, actualRenderedSizeFact));
}

sbcol2qcol()

QColor VP1QtInventorUtils::sbcol2qcol ( const SbColor & col )

static

Definition at line 1145 of file VP1QtInventorUtils.cxx.

{
    float r,g,b;
    col.getValue(r,g,b);
    return QColor::fromRgbF( r,g,b );
}

serialiseSoMaterial()

QByteArray VP1QtInventorUtils::serialiseSoMaterial ( SoMaterial * m )

static

Definition at line 1153 of file VP1QtInventorUtils.cxx.

{
    if (!m||m->ambientColor.getNum()!=1
            ||m->diffuseColor.getNum()!=1
            ||m->specularColor.getNum()!=1
            ||m->emissiveColor.getNum()!=1
            ||m->transparency.getNum()!=1
            ||m->shininess.getNum()!=1) {
        VP1Msg::message("VP1QtInventorUtils::serialiseSoMaterial Error: "
                "Passed material must have exactly one value in each of the 6 fields!!");
        return QByteArray();
    }
 
 
    // ===> Setup stream writing to a byteArray:
    QByteArray byteArray;
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);
    QDataStream out(&buffer);
 
    //Write data:
    out << QString("somat_v1_begin");
    out << sbcol2qcol(m->ambientColor[0]);
    out << sbcol2qcol(m->diffuseColor[0]);
    out << sbcol2qcol(m->specularColor[0]);
    out << sbcol2qcol(m->emissiveColor[0]);
    out << (double)m->shininess[0];
    out << (double)m->transparency[0];
    out << QString("somat_end");
 
    // ===> Finish up:
    buffer.close();
 
    return byteArray;
 
}

serialize() [1/2]

QByteArray VP1QtInventorUtils::serialize ( const SbRotation & rot )

static

Definition at line 730 of file VP1QtInventorUtils.cxx.

{
 
    // ===> Setup stream writing to a byteArray:
    QByteArray byteArray;
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);
    QDataStream out(&buffer);
 
    //Write data:
 
    float q0,q1,q2,q3;//quarternion components
    rot.getValue (q0,q1,q2,q3);
 
    out<<(double)q0;
    out<<(double)q1;
    out<<(double)q2;
    out<<(double)q3;
 
    if (VP1Msg::verbose()) {
        //Fixme: check for nan's.
        VP1Msg::messageVerbose("VP1QtInventorUtils::serialize SbRotation(q0,q1,q2,q3) = ("
                +QString::number(q0)+", "+QString::number(q1)+", "
                +QString::number(q2)+", "+QString::number(q3)+")");
    }
 
    // ===> Finish up:
    buffer.close();
    return byteArray;
}

serialize() [2/2]

QByteArray VP1QtInventorUtils::serialize ( const SbVec3f & vec )

static

Definition at line 814 of file VP1QtInventorUtils.cxx.

{
    // ===> Setup stream writing to a byteArray:
    QByteArray byteArray;
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);
    QDataStream out(&buffer);
 
    //Write data:
    float x,y,z;
    vec.getValue(x,y,z);
    out << (double)x;
    out << (double)y;
    out << (double)z;
 
    if (VP1Msg::verbose()) {
        //Fixme: check for nan's.
        VP1Msg::messageVerbose("VP1QtInventorUtils::serialize SbVec3f(x,y,z) = ("
                +QString::number(x)+", "+QString::number(y)+", "+QString::number(z)+")");
    }
 
    // ===> Finish up:
    buffer.close();
    return byteArray;
}

serializeSoCameraParameters()

QByteArray VP1QtInventorUtils::serializeSoCameraParameters ( const SoCamera & cam )

static

Definition at line 889 of file VP1QtInventorUtils.cxx.

                                                                                {
 
    VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters start");
 
    // ===> Setup stream writing to a byteArray:
    QByteArray byteArray;
    QBuffer buffer(&byteArray);
    buffer.open(QIODevice::WriteOnly);
    QDataStream out(&buffer);
 
    cam.ref();
    //Write data:
    SbRotation camrot = cam.orientation.getValue();
    out << serialize(camrot);
    SbVec3f campos = cam.position.getValue();
    out << serialize(campos);
    float f_aspectRatio(cam.aspectRatio.getValue());
    float f_nearDistance(cam.nearDistance.getValue());
    float f_farDistance(cam.farDistance.getValue());
    float f_focalDistance(cam.focalDistance.getValue());
    out << (double)f_aspectRatio;
    out << (double)f_nearDistance;
    out << (double)f_farDistance;
    out << (double)f_focalDistance;
 
    int viewportmap(-1);
    switch (cam.viewportMapping.getValue()) {
    case SoCamera::CROP_VIEWPORT_FILL_FRAME: viewportmap = 0;break;
    case SoCamera::CROP_VIEWPORT_LINE_FRAME: viewportmap = 1;break;
    case SoCamera::CROP_VIEWPORT_NO_FRAME: viewportmap = 2;break;
    case SoCamera::ADJUST_CAMERA: viewportmap = 3;break;
    case SoCamera::LEAVE_ALONE: viewportmap = 4;break;
    }
    out << viewportmap;
 
    //Camera type and specialised info:
    int camtype (-1);
    if (cam.getTypeId().isDerivedFrom(SoPerspectiveCamera::getClassTypeId()))
        camtype = 0;
    else if (cam.getTypeId().isDerivedFrom(SoOrthographicCamera::getClassTypeId()))
        camtype = 1;
 
    out <<camtype;
    if (camtype==0) {
        out << (double)static_cast<const SoPerspectiveCamera*>(&cam)->heightAngle.getValue();
    } else if (camtype==1) {
        out << (double)static_cast<const SoOrthographicCamera*>(&cam)->height.getValue();
    }
 
    cam.unrefNoDelete();
 
    // ===> Finish up:
    buffer.close();
 
    if (VP1Msg::verbose()) {
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters aspectRatio = "+QString::number(f_aspectRatio));
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters nearDistance = "+QString::number(f_nearDistance));
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters farDistance = "+QString::number(f_farDistance));
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters focalDistance = "+QString::number(f_focalDistance));
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters viewportmap = "+QString::number(viewportmap));
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters camtype = "
                +QString(camtype==0?"perspective":(camtype==1?"orthographic":"unknown")));
        if (camtype==0)
            VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters (persp) heightAngle = "
                    +QString::number(static_cast<const SoPerspectiveCamera*>(&cam)->heightAngle.getValue()));
        if (camtype==1)
            VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters (ortho) height = "
                    +QString::number(static_cast<const SoOrthographicCamera*>(&cam)->height.getValue()));
        VP1Msg::messageVerbose("VP1QtInventorUtils::serializeSoCameraParameters end");
    }
 
    return byteArray;
}

setLimitsLineWidthSlider()

void VP1QtInventorUtils::setLimitsLineWidthSlider ( QSlider * slider )

static

Definition at line 1566 of file VP1QtInventorUtils.cxx.

{
    if (!slider)
        return;
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    int nsteps = std::min(1000,std::max<int>(0,static_cast<int>((Imp::allowedLineWidthMax-Imp::allowedLineWidthMin)/Imp::allowedLineWidthGranularity)));
    int stepsPerUnit = std::min(nsteps,std::max<int>(1,static_cast<int>(1.0/Imp::allowedLineWidthGranularity)));
    slider->setRange(0,nsteps);
    slider->setSingleStep(1);
    slider->setPageStep(stepsPerUnit);
}

setLimitsPointSizeSlider()

void VP1QtInventorUtils::setLimitsPointSizeSlider ( QSlider * slider )

static

Definition at line 1580 of file VP1QtInventorUtils.cxx.

{
    if (!slider)
        return;
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    int nsteps = std::min(1000,std::max<int>(0,
            static_cast<int>(0.5+(Imp::allowedPointSizeMax-Imp::allowedPointSizeMin)/Imp::allowedPointSizeGranularity)));
    int stepsPerUnit = std::min(nsteps,std::max<int>(1,
            static_cast<int>(0.5+1.0/Imp::allowedPointSizeGranularity)));
    slider->setRange(0,nsteps);
    slider->setSingleStep(1);
    slider->setPageStep(stepsPerUnit);
}

setMatColor() [1/2]

void VP1QtInventorUtils::setMatColor ( SoMaterial * m, const double & r, const double & g, const double & b, const double & brightness = 0.0, const double & transp = 0.0 )

static

Definition at line 1485 of file VP1QtInventorUtils.cxx.

{
    if (m)
        VP1MaterialButton::setMaterialParameters( m, r,g,b,brightness,transp );
}

setMatColor() [2/2]

void VP1QtInventorUtils::setMatColor ( SoMaterial * m, const QColor & col, const double & brightness = 0.0, const double & transp = 0.0 )

static

Definition at line 1493 of file VP1QtInventorUtils.cxx.

{
    setMatColor( m, col.redF(), col.greenF(), col.blueF(), brightness, transp);
}

setValueLineWidthSlider()

void VP1QtInventorUtils::setValueLineWidthSlider ( QSlider * slider, const double & value )

static

Definition at line 1596 of file VP1QtInventorUtils.cxx.

{
    if (!slider)
        return;
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    int itarget = std::min(slider->maximum(),std::max<int>(slider->minimum(),
            static_cast<int>(0.5+(value-Imp::allowedLineWidthMin)/Imp::allowedLineWidthGranularity)));
    if (slider->value()!=itarget)
        slider->setValue(itarget);
}

setValuePointSizeSlider()

void VP1QtInventorUtils::setValuePointSizeSlider ( QSlider * slider, const double & value )

static

Definition at line 1609 of file VP1QtInventorUtils.cxx.

{
    if (!slider)
        return;
    if (Imp::lineWidthAndPointSizeNeedsInit)
        ensureInitLineWidthAndPointSize(0);
    int itarget = std::min(slider->maximum(),std::max<int>(slider->minimum(),
            static_cast<int>(0.5+(value-Imp::allowedPointSizeMin)/Imp::allowedPointSizeGranularity)));
    if (slider->value()!=itarget)
        slider->setValue(itarget);
}

transparencyType2PrettyString()

QString VP1QtInventorUtils::transparencyType2PrettyString ( SoGLRenderAction::TransparencyType tt )

static

Definition at line 710 of file VP1QtInventorUtils.cxx.

{
    switch (tt) {
    case SoGLRenderAction::DELAYED_BLEND: return "Delayed blend"; break;
    case SoGLRenderAction::SCREEN_DOOR: return "Screen door"; break;
    case SoGLRenderAction::ADD: return "Add"; break;
    case SoGLRenderAction::DELAYED_ADD: return "Delayed add"; break;
    case SoGLRenderAction::SORTED_OBJECT_ADD: return "Sorted object add"; break;
    case SoGLRenderAction::BLEND: return "Blend (Best for Geo volumes)"; break;
    case SoGLRenderAction::SORTED_OBJECT_BLEND: return "Sorted object blend (Best for physics objects: jets, tracks, ...)"; break;
    case SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_ADD: return "Sorted object sorted triangle add"; break;
    case SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND: return "Sorted object sorted triangle blend"; break;
    case SoGLRenderAction::NONE: return "None"; break;
    case SoGLRenderAction::SORTED_LAYERS_BLEND: return "Sorted layers blend"; break;
    default: return "";
    }
 
}

transparencyTypeToInt()

int VP1QtInventorUtils::transparencyTypeToInt ( SoGLRenderAction::TransparencyType tt )

static

Definition at line 668 of file VP1QtInventorUtils.cxx.

{
    switch (tt) {
    case SoGLRenderAction::SCREEN_DOOR: return 0;
    case SoGLRenderAction::ADD: return 1;
    case SoGLRenderAction::DELAYED_ADD: return 2;
    case SoGLRenderAction::SORTED_OBJECT_ADD: return 3;
    case SoGLRenderAction::BLEND: return 4;
    case SoGLRenderAction::DELAYED_BLEND: return 5;
    case SoGLRenderAction::SORTED_OBJECT_BLEND: return 6;
    case SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_ADD: return 7;
    case SoGLRenderAction::SORTED_OBJECT_SORTED_TRIANGLE_BLEND: return 8;
    case SoGLRenderAction::NONE: return 9;
    case SoGLRenderAction::SORTED_LAYERS_BLEND: return 10;
    default:
        VP1Msg::messageDebug("VP1QtInventorUtils::transparencyTypeToInt ERROR: Unknown transparency type");
        return -1;
    }
}

writeGraphToFile()

bool VP1QtInventorUtils::writeGraphToFile ( SoNode * root, const QString & filename )

static

Definition at line 1426 of file VP1QtInventorUtils.cxx.

{
    if (!root)
        return false;
 
    root->ref();
    QString s = Imp::buffer_writeaction(root);
    root->unrefNoDelete();
 
    QFile data(filename);
    if (data.open(QFile::WriteOnly | QFile::Truncate)) {
        QTextStream out(&data);
#if QTCORE_VERSION >= 0x050E00
        out << s << Qt::endl;
#else
        out << s << endl;
#endif
        return true;
    } else {
        return false;
    }
}

writeGraphToVRMLFile()

bool VP1QtInventorUtils::writeGraphToVRMLFile ( SoNode * root, const QString & filename )

static

Definition at line 1461 of file VP1QtInventorUtils.cxx.

{
    if (!root)
        return false;
 
    root->ref();
    Imp::buffer_vrmlwriteaction(root, filename);
    root->unrefNoDelete();
 
    // QFile data(filename);
    // if (data.open(QFile::WriteOnly | QFile::Truncate)) {
    //  QTextStream out(&data);
    //  out << s << endl;
    //  return true;
    // } else {
    //  return false;
    // }
    return true;
}

---

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

• VP1QtInventorUtils.h
• VP1QtInventorUtils.cxx