XML3DRenderer.h

Go to the documentation of this file.

// -*- Mode: C++; tab-width: 2; -*-
// vi: set ts=2:
//

#ifndef BALL_VIEW_RENDERING_RENDERERS_XML3DRENDERER_H
#define BALL_VIEW_RENDERING_RENDERERS_XML3DRENDERER_H

#ifndef BALL_VIEW_RENDERING_RENDERERS_RENDERER_H
# include <BALL/VIEW/RENDERING/RENDERERS/renderer.h>
#endif

#ifndef BALL_SYSTEM_FILE_H
# include <BALL/SYSTEM/file.h>
#endif

#ifndef BALL_MATHS_VECTOR3_H
# include <BALL/MATHS/vector3.h>
#endif

#ifndef BALL_MATHS_MATRIX44_H
# include <BALL/MATHS/matrix44.h>
#endif

#ifndef BALL_MATHS_SURFACE_H
# include <BALL/MATHS/surface.h>
#endif

namespace BALL
{
  namespace VIEW
  {
    class ColorRGBA;
    class ClippingPlane;

    class BALL_VIEW_EXPORT XML3DRenderer : public Renderer
    {
      public:

      BALL_CREATE(XML3DRenderer)

      struct XML3DRendererClippingPlane
      {
        public:
          Vector3 normal;
          float translation;
//           Vector3 translation;
      };


      XML3DRenderer();

      XML3DRenderer(const String& name)
        throw(Exception::FileNotFound);
      
      XML3DRenderer(std::ostream& name);
      
      // Only for Python
      XML3DRenderer(const XML3DRenderer& renderer);


      virtual ~XML3DRenderer();

      virtual void clear();



      virtual void setSize(float width, float height);

      void setFileName(const String& name)
        throw(Exception::FileNotFound);

      void setOstream(std::ostream& out_stream);

      void setHumanReadable(bool state)
        { human_readable_ = state;}

      bool isHumanReadable() const
        { return human_readable_;}

      String XML3DColorRGBA(const ColorRGBA& input, const String& name);

      String XML3DFinish(const String& object, const ColorRGBA& input);

      String XML3DRaytracingMaterial(const Stage::Material& input);

      String XML3DVector3(Vector3 input);

      String XML3DString(const String& input);

      virtual bool renderOneRepresentation(const Representation& representation);

      

      virtual bool init(Scene& scene);

      virtual bool init(const Stage& stage, float width, float height);

      virtual bool finish();
      
      void createXHTMLHeader();

      void createXHTMLFooter();

      void renderSphere_(const Sphere& sphere);
      
      void renderDisc_(const Disc& disc);

      void renderTube_(const Tube& tube);

      void renderTwoColoredTube_(const TwoColoredTube& tube);

      void renderMesh_(const Mesh& mesh);

      void renderTwoColoredLine_(const TwoColoredLine& line);

      void renderLine_(const Line& line);

      void renderPoint_(const Point& point);

      // do nothing
      void renderLabel_(const Label&);
      
      virtual void renderMultiLine_(const MultiLine& line);


      protected:

        const ColorRGBA& getColor_(const GeometricObject& object);
      
        std::ostream* outfile_;
        String trimFloatValue_(float value);
        void storeColor_(const GeometricObject& object);
        String getColorIndex_(const ColorRGBA& color);
        void createTubeTransform_(const TwoColoredTube& tube);
        void createSphereTemplate_();


        Vector3   origin_;
        Matrix4x4 rotation_;
        vector<ClippingPlane*> clipping_planes_;
        bool human_readable_;

        typedef HashMap<String, Size> ColorMap;
        ColorMap color_map_;
        vector<const Representation*> representations_;
        HashSet<const Mesh*> wireframes_;
        HashSet<String> color_strings_;
        double m_[12];
        Position color_index_;
        bool create_XHTML_;

        Surface sphere_template_;
        Surface tube_template_;

        Stage::Material rt_material_;

        Index current_sphere_number_;
        Index current_tube_number_;

        float fov_x_;
        float fov_y_;
    };
  
  } // namespace BALL
} // namespace VIEW

#endif // BALL_VIEW_RENDERING_XML3DRENDERER_H