source: GTP/trunk/Lib/Vis/Preprocessing/src/X3dExporter.h @ 2124

#ifndef __X3DEXPORTER_H
#define __X3DEXPORTER_H

#include <string>
using std::string;

#include <iostream>
#include <fstream>

#include "Exporter.h"
#include "Containers.h"
#include "VssRay.h"
#include "ViewCell.h"

namespace GtpVisibilityPreprocessor {

class SceneGraphNode;
class Mesh;
class Intersectable;
class MeshInstance;
class Polygon3;
class ViewCell;
class BspTree;
class VspBspTree;
class BspNode;
class Beam;


class X3dExporter : public Exporter
{
        std::ofstream stream;

public:

        X3dExporter(const string filename);

        ~X3dExporter();

        bool
                ExportKdTree(const KdTree &tree, const bool exportGeometry = false);

        bool
                ExportVssTree(const VssTree &tree);

        bool
                ExportVssTree2(const VssTree &tree,
                const Vector3 direction);

        virtual bool
                ExportRssTree2(const RssTree &tree,
                const Vector3 direction);

        bool ExportBspTree(const BspTree &tree);

        bool
                ExportScene(SceneGraphNode *root)
        {
                ExportSceneNode(root);
                return true;
        }

        virtual void
                ExportPolygon(Polygon3 *poly);

        virtual void
                ExportPolygons(const PolygonContainer &polys);

        virtual bool
                ExportBox(const AxisAlignedBox3 &box);

        virtual void
                ExportMesh(Mesh *mesh);

        virtual void
                ExportViewCell(ViewCell *viewCell);

        bool
                ExportRays(const RayContainer &rays,
                const float length=1000,
                const RgbColor &color = RgbColor(1,1,1));

        bool
                ExportRays(const VssRayContainer &rays,
                const RgbColor &color = RgbColor(1,1,1));

        virtual void
                ExportBspSplitPlanes(const BspTree &tree);

        virtual void
                ExportBspSplits(const BspTree &tree, const bool exportDepth);

        virtual void
                ExportLeavesGeometry(const BspTree &tree, const vector<BspLeaf *> &leaves);

        virtual void ExportBspLeaves(const BspTree &tree, const int maxPvs = 0);

        virtual void ExportBspSplits(const VspBspTree &tree, const bool exportDepth);

        virtual void ExportBeam(const Beam &beam, const AxisAlignedBox3 &box);

        bool ExportRaySets(const vector<VssRayContainer> &rays,
                                           const RgbColor &color);


protected:

        virtual void ExportSceneNode(SceneGraphNode *node);

        bool ExportKdTreeRayDensity(const KdTree &tree);

        bool ExportBspTreeRayDensity(const BspTree &tree);

        void ExportBspNodeSplits(BspNode *root,
                                                         const AxisAlignedBox3 &box,
                                                         const bool exportDepth,
                                                         const bool epsilon);

        void ExportViewpoint(const Vector3 &point, const Vector3 &direction);
};

};

#endif