---

qsaxes3d.h

/***************************************************************************
                                  qsaxes3d.h
                             -------------------                                         
    begin                : 01-January-2000
    copyright            : (C) 2000 by Kamil Dobkowski                         
    email                : kamildobk@poczta.onet.pl                                     
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   * 
 *                                                                         *
 ***************************************************************************/


#ifndef QSAXES3D_H
#define QSAXES3D_H

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include"qsaxes.h"
#include"qsprojection3d.h"




class QSAxes3D : public QSAxes
  {
   Q_OBJECT
    Q_PROPERTY( bool openGL READ openGL WRITE setOpenGL )
    Q_PROPERTY( bool glTransparency READ glTransparency WRITE glSetTransparency )
    Q_PROPERTY( int glGlobalTransparency READ glGlobalTransparency WRITE glSetGlobalTransparency )
    Q_PROPERTY( bool glShadeWalls READ glShadeWalls WRITE glSetShadeWalls )
    Q_PROPERTY( bool glMeshAutoStroke READ glMeshAutoStroke WRITE glSetMeshAutoStroke )
    Q_PROPERTY( int glAutoStrokeLightness READ glAutoStrokeLightness WRITE glSetAutoStrokeLightness )
    
    Q_PROPERTY( double xEdgeLength READ xEdgeLength WRITE setXEdgeLength )
    Q_PROPERTY( double yEdgeLength READ yEdgeLength WRITE setYEdgeLength )
    Q_PROPERTY( double zEdgeLength READ zEdgeLength WRITE setZEdgeLength )
    Q_PROPERTY( double xyWallThickness READ xyWallThickness WRITE setXYWallThickness )
    Q_PROPERTY( double xzWallThickness READ xzWallThickness WRITE setXZWallThickness )  
    Q_PROPERTY( double yzWallThickness READ yzWallThickness WRITE setYZWallThickness )
    
    Q_PROPERTY( int azimuth READ azimuth WRITE setAzimuth )
    Q_PROPERTY( int elevation READ elevation WRITE setElevation )
    Q_PROPERTY( int distance READ distance WRITE setDistance )
    Q_PROPERTY( int focusDistance READ focusDistance WRITE setFocusDistance )
    Q_PROPERTY( int lightAzimuth READ lightAzimuth WRITE setLightAzimuth )
    Q_PROPERTY( int lightElevation READ lightElevation WRITE setLightElevation )
    Q_PROPERTY( int directLight READ directLight WRITE setDirectLight )
    Q_PROPERTY( int ambientLight READ ambientLight WRITE setAmbientLight )

    Q_PROPERTY( bool perspective READ perspective WRITE setPerspective )
    Q_PROPERTY( bool autoscale READ autoscale WRITE setAutoscale )
    Q_PROPERTY( bool light READ light WRITE setLight )


   public:
     QSAxes3D(QObject* parent=0, const char * name=0);
     virtual ~QSAxes3D();
     void stop();
     void setOpenGL( bool enabled );
     bool openGL() const { return m_gl.enabled; }
     void glSetTransparency( bool enabled );
     void glSetGlobalTransparency( int value );
     void glSetShadeWalls( bool enabled );
     void glSetMeshAutoStroke( bool enable );
     void glSetAutoStrokeLightness( int value );
     bool glTransparency() const { return m_gl.transparency; }
     bool glShadeWalls() const { return m_gl.shadewalls; }
     int glGlobalTransparency() const { return m_gl.globaltr; }
     bool glMeshAutoStroke() const { return m_gl.autostroke; }
     int glAutoStrokeLightness() const { return m_gl.autostrokel; }
     void setEdgeLength( double xEdge, double yEdge, double zEdge );
     void setXEdgeLength( double lenght );
     void setYEdgeLength( double lenght );
     void setZEdgeLength( double lenght );
     double xEdgeLength() const { return m_view.xEdge; }
     double yEdgeLength() const { return m_view.yEdge; }
     double zEdgeLength() const { return m_view.zEdge; }
     void setWallThickness( double xy, double xz, double yz );
     void setXYWallThickness( double thickness );
     void setXZWallThickness( double thickness );
     void setYZWallThickness( double thickness );
     double xyWallThickness() const { return m_view.xyThick; }
     double xzWallThickness() const { return m_view.xzThick; }
     double yzWallThickness() const { return m_view.yzThick; }
     int azimuth() const { return m_view.azimuth; }
     int elevation() const { return m_view.elevation; }
     int distance() const { return m_view.distance; }
     int focusDistance() const { return m_view.focus; }
       int lightAzimuth() const { return m_view.lightAzimuth; }
       int lightElevation() const { return m_view.lightElevation; }
     int directLight() const { return m_view.directLight; }
     int ambientLight() const { return m_view.ambientLight; }
     void setPerspective( bool enabled );
     void setAutoscale( bool enabled );
     void setLight( bool enabled );
     bool light() const { return m_view.lighted; }
     bool perspective() const { return m_view.perspective; }
     bool autoscale() const { return m_view.autoscale; }
     void defaultSettings();
     const QSProjection3D *p3D() const { return &t; }
     virtual void initMappings( QSDrv *drv );
     virtual QSPt3f mixedToCanvas( const QSPt3f& pos, CoordinateSystem in_coords[3], double dpi, QSAxis *xAxis, QSAxis *yAxis, QSAxis *zAxis ) const;
     virtual QSPt3f canvasToMixed( const QSPt3f& pos, CoordinateSystem out_coords[3], double dpi, QSAxis *xAxis, QSAxis *yAxis, QSAxis *zAxis ) const;
     virtual void paintPlot( QPainter *p, double dpi=72.0, bool blocking=true, bool transparent=true );
     virtual void drawPlot( QSDrv *drv, bool blocking=true, bool transparent=true );
     virtual void paintSkeleton( QPainter *p, double dpi=72.0, bool reallyFast=false );
     enum FillElement {
                        BWallFill,
                        RWallFill,
            XYWallFill,
            XZWallFill,
            YZWallFill
                       };
     enum LineElement { BoxLine   = 0,
                        TicsLine,
            XYWallLine,
            XZWallLine,
            YZWallLine
                      };

    virtual void loadStateFromStream( QDataStream& stream, QSObjectFactory *factory );
    virtual void saveStateToStream( QDataStream& stream, QSObjectFactory *factory );

   public slots:
     void setAzimuth( int angle );
     void setElevation( int angle );
     void setDistance( int d );
     void setFocusDistance( int d );
     void setLightAzimuth( int azimuth );
     void setLightElevation( int elevation );
     void setDirectLight( int lightness );
     void setAmbientLight( int lightness );

    protected:
     virtual void axisRangesCalculated();
     virtual void allocRuntimeData();
     virtual void freeRuntimeData();
     virtual void drawAxis( QSAxis *axis );
     virtual void drawGrid( QSAxis *axis, bool major );

    private:
     // drawing parameters
     struct view_t {

           int  azimuth;
           int  elevation;
           int  distance;
           int  focus;
           int  lightAzimuth;
           int  lightElevation;
           int  directLight;
           int  ambientLight;
           bool lighted;
           bool perspective;
           bool autoscale;
       double xEdge;
       double yEdge;
       double zEdge;
       double xyThick;
       double xzThick;
       double yzThick;
          } m_view;

     struct gl_t {
         bool enabled;
         bool transparency;
         bool autostroke;
         bool shadewalls;
         int autostrokel;
         int globaltr;
        } m_gl;

     QSProjection3D t;
     QSDrv::CNormals  m_cnormals;
     QSDrv::CColors   m_ccolors;
     QSDrv::COrdering m_corder;

    class qsaxes3d_runtime_data;
     qsaxes3d_runtime_data *d;

     bool m_is_graphics_active;
     void init_3dtr();
     void draw_arrow();
     void draw_box();
     void draw_grid( QSAxis *axis, bool major, QSPt3f p[4], QSPt3f norm[5] );
     void draw_line( QSPt3f p1, QSPt3f p2, QSPt3f *normals = NULL );
     void get_side_wall( const QSPt3f& p1, const QSPt3f& p2, int side_nr, QSPt3f result_pts[4], QSPt3f result_norm[5] );
     void get_axis_wall( int wall_nr, QSPt3f *p1, QSPt3f *p2, bool *visible );
     void get_axis_lengths( double *xaxis_scale, double *yaxis_scale, double *zaxis_scale );
     void get_cube_min_max( QSPt3f* min, QSPt3f *max );
     int get_label_align( const QSPt3f& p1, const QSPt3f& p2, int axis );
     bool visible( const QSPt3f& p, const QSPt3f& norm );
     double opposite_side( double value );
     QSPt3f thickness( int wall_nr );
     bool point_on_side( const QSPt3f& p, int side );

  };

#endif

---