u3d_surfsource.hpp

/* u3d_surfsource.hpp */
/* $Id: u3d_surfsource.hpp,v 1.1 2008/05/13 12:19:18 sad Exp $ */
//------------------------------------------------------------------------------
#ifndef __u3d_surfsourcehpp
#define __u3d_surfsourcehpp

#include "u3d_rtmod_defines.hpp"
#include <mth/u3d_box.hpp>
#include <mth/u3d_math_abstract_surface.hpp>
#include <mth/u3d_triangled_abstract_surface.hpp>


//==============================================================================
class U3dSurfSource 
{
  friend bool comp2SurfTest(const U3dSurfSource& s1, const U3dSurfSource& s2);

public:

  U3dSurfSource(U3dMathAbstractSurface *mathsurf_in, U3dCodeAr wc, int bId, float stp);    // unstable constructor !!!!
  U3dSurfSource(U3dTriangledAbstractSurface *triansurf_in, U3dCodeAr wc, int bId, float stp);  
 
  U3dSurfSource(U3dTriangledAbstractSurface *triansurf_in, const char* data, int size) :
    m_mathsurf(NULL),
    m_triansurf(triansurf_in)
  { 
    deserialize(data, size); 
  }

  ~U3dSurfSource();

  void    setIJCell(U3dPoint p, double stF, double stAz, double T,
            double F, double Az, double nF, double nAz);
    
  void    getIJ(U3dPoint p, int &i, int &j);

  int     getIMax() { return m_p_size; }
  int     getJMax() { return m_q_size; }

  SSPQCell getCell(int i, int j) { return m_pqgrid[i][j]; }
  U3dPoint getCellPoint(int i, int j);
  U3dPoint getCellInitPoint(int i, int j);

  double   getIJStF(int i, int j) { return m_pqgrid[i][j].st_f; }
  double   getIJStAz(int i, int j) { return m_pqgrid[i][j].st_az; }

  double   getIJT(int i, int j) { return m_pqgrid[i][j].t; }
  double   getIJF(int i, int j) { return m_pqgrid[i][j].f; }
  double   getIJAz(int i, int j) { return m_pqgrid[i][j].az; }
  double   getIJNF(int i, int j) { return m_pqgrid[i][j].n_f; }
  double   getIJNAz(int i, int j) { return m_pqgrid[i][j].n_az; }

  void     setShadowedFlag(int i, int j) { m_pqgrid[i][j].t = -2; }  
  
  bool     getReady()  { return m_ready; }
  int      getBoundId() { return m_bound_id; }

  U3dCodeAr getCode() const { return m_wave_code; }
  
  U3D_WAVE_TYPE getWType() { return m_wave_code[0].wType; }
  const U3dTriangledAbstractSurface* getTrSurf() { return m_triansurf; }
  const U3dMathAbstractSurface*      getMathSurf() { return m_mathsurf; }

  void    serialize(char** data, int* size);


  void    deserialize(const char* data, int size);

  
  void setID(int id) { m_queue_ID=id; };


  int getID() { return m_queue_ID; };


private:

  int m_queue_ID;
  
  U3dMathAbstractSurface      *m_mathsurf;   
  U3dTriangledAbstractSurface *m_triansurf;  
  SSPQCell       **m_pqgrid;        
  U3dCodeAr        m_wave_code;
  int              m_bound_id;
  


  float            m_step_x;             
  float            m_step_y;             
  int              m_p_size;             
  int              m_q_size;             
  float           *m_xgrid;              
  float           *m_ygrid;              
  double           m_xmn;               
  double           m_xmx;
  double           m_ymn;
  double           m_ymx;

  bool             m_ready;             
};
  

//----------------------------------------------------------------------------
#endif /* u3d_surfsource.hpp */