FemViewer Namespace Reference

Namespaces

namespace  ELEMS
namespace  fvmath
namespace  GlutGUI
namespace  MIC
namespace  Win
namespace  WxGUI

Classes

class  Accelerator
class  BVH
class  Grid
struct  gridinfo_t
class  ModuleThread
class  AppImpl
class  AppImpl< T * >
struct  Start< T, ALONE >
struct  Start< T, MASTER >
struct  Start< T, SLAVE >
struct  AAbb
class  BBox3D
struct  Camera
struct  RGBColor
struct  RGBAColor
struct  ColorHSV
class  HSV
class  ColorRGB
class  ColorRGBA
class  ColorBar
class  mfvSingleton
class  mfvSingleton< T * >
class  Vec
class  Array
class  Array2
class  CutPlane
struct  BaseId
class  Id
class  ElemId
struct  FaceId
struct  CompareBndAct
struct  ElemInfo
class  FemViewerApp
class  Field
class  Fire
struct  pixel_descr_t
 pixel format descriptor More...
class  GLCore
struct  IsectData
struct  prism_info
struct  coeffs_info
union  coef_t
struct  intersect_t
class  mfvBaseObject
class  mfvObject
class  Triangle
class  Tetra
class  Prizm
class  GLRenderBase
class  RenderObject
class  GraphicData
class  TransferFunction
struct  Breakpoint
class  HostTransferFunction
class  RenderObject< TypeOfRenderer::Wireframe >
class  RenderObject< TypeOfRenderer::WireframeSlice >
class  RenderObject< TypeOfRenderer::ColorMap >
class  RenderObject< TypeOfRenderer::ColorMapSlice >
class  RenderObject< TypeOfRenderer::ColorMapStd >
class  RenderObject< TypeOfRenderer::ColorMapStdSlice >
class  RenderManager
class  GraphicsSettings
class  GraphElement
struct  LegendData
class  Legend
struct  colormap_value
class  Light
class  Log
class  Matrix
class  Mesh
class  Octree
class  BaseInfo
class  MeshInfo
class  FieldInfo
struct  VisualInfo
class  BaseHandle
struct  MeshHandle
struct  FieldHandle
struct  grh_data
class  ModelItem
class  Model
class  ModelCtrl
class  Object
class  Plane
class  Point3D
class  PrimitiveAccumulator
class  IsectInfo
class  Ray
class  RContext
struct  BaseParams
struct  RenderParams
class  Shader
class  EdgeShader
class  TriangleShader
class  TriStripsVGFShader
class  GLShader
class  GLShaderProgram
class  StartupSettings
class  Tile
class  Vec3D
class  View
class  ViewManager
class  VtxAccumulator
class  VtxPrimitiveAccumulator
class  mfvWindow
class  Interval
struct  SimplificationPoint
struct  shader_srcs
class  ArrayT
struct  SolutionData
class  BaseField
class  TArrayPtrs
class  BaseMesh
struct  isect_info_t
struct  el_isect_info_t
struct  _Node_t
struct  BaseVertex
struct  Vertex
struct  MeshVertex
struct  BaseVertexInserterID
struct  colorbar_config_t
struct  Vertex2D
struct  CVertex2D
struct  label_t

Typedefs

typedef AAbb< float > AAbbf
typedef AAbb< double > AAbbd
typedef struct
FemViewer::pixel_descr_t * 		pixel_descrptr_t
typedef struct
FemViewer::colormap_value 		colormap_value
typedef Matrix< float > Matrixf
typedef Matrix< double > Matrixd
typedef enum FemViewer::eRenderType glsl_program_type
typedef void(VtxAccumulator::* drawMethod )(const RenderParams &)
typedef Win::MainApp AppEngine
typedef WxGUI::wxFemViewerApp GUIEngine
typedef enum
FemViewer::TypeOfRenderer 		object_type
typedef enum
FemViewer::RenderGLTypes 		gl_object_type
typedef struct FemViewer::_Node_t Node_t
typedef BaseVertex Origin

Enumerations

enum  InstantType { MODULE, APPLICATION }
enum  CoreType { ALONE = 0, MASTER, SLAVE, COUNT }
enum  { left, up }
enum  { flat, gradient }
enum  ePixelFormat {
  PF_UNKNOWN = 0, PF_R8, PF_RG8, PF_RGB8,
  PF_RGBA8, PF_RGBA8_SRGB, PF_BGRA8_SRGB, PF_ALL
}
enum  eShaderType {
  SH_VERTEX = 0x01, SH_GEOMETRY = 0x02, SH_FRAGMENT = 0x04, SH_TESELATOR = 0x08,
  SH_COMPUTE = 0x10
}
enum  tf_chanel_t { eDensity, eRed, eGreen, eBlue }
enum  { EDGE_RENDERER, TRIANGLE_RENDERER, TRAINGLE_STRIP_RENDERER }
enum  RenderCore { CORE_GL = 0, CORE_OPENCL }
enum  LegendType { SOLID = 0, GRADIENT = 1 }
enum  LegendValueType {
  NON = 0, BORDER = 1, INSIDE = 2, OUTSIDE = 4,
  START = 8, END = 16, LVT_COLOR = 32
}
enum  {
  NOWERE = 0x0000, LOGCONSOLE = 0x0001, LOGFILE = 0x0010, LOGDIALOG = 0x0100,
  LOGEXTERNAL = 0x1000
}
enum  eLevel {
  LogERROR = 0, LogWARNING, LogINFO, LogDEBUG,
  LogDEBUG1
}
enum  eRenderType {
  SH_UNKNOWN = -1, SH_EDGE = 0, SH_TRIANGLE, SH_TRIANGLE_STRIP,
  SH_ALL
}
enum  glslshader_type {
  EDGE_VERT = 0, EDGE_FRAG, TRI_VERT, TRI_GEOM,
  TRI_FRAG, TRISTRIP_GEOM
}
enum  ElemType {
  REFIN = -1, FREE = 0, PRIZM = 5, BRICK = 6,
  TETRA = 7
}
enum  FaceType { F_TRIA = 3, F_QUAD = 4 }
enum  RefinementType { NOT_REF = 0, REF_ISO = 1 }
enum  BaseType { TENSOR = 0, COMPLETE = 1 }
enum  ModuleType { INTERNAL = 0, EXTERNAL }
enum  ApproximationType { LINEAR = 0, HIGH_ORDER }
enum  GLListType {
  NUM_VERTICES_LIST_WIREFRAME = 0, NUM_ELEMENTS_LIST_WIREFRAME, NUM_VERTICES_LIST_COLORMAP, NUM_ELEMENTS_LIST_COLORMAP,
  NUM_VERTICES_LIST_CUTTED_WIREFRAME, NUM_ELEMENTS_LIST_CUTTED_WIREFRAME, NUM_VERTICES_LIST_CUTTED_COLORMAP, NUM_ELEMENTS_LIST_CUTTED_COLORMAP,
  COLORBAR_LIST0, COLORBAR_LIST1, COLORBAR_LIST2, ID_COLORMAP_TEXT,
  ID_GRID, ID_AXES, NUM_TOTAL_LISTS
}
enum  Render_t { RASTERIZATION_GL = 0, RAYTRACE_GL_CL }
enum  HandleType {
  Unknown = -1, MeshPrizm = 0, MeshHybrid = 1, MeshRemesh = 2,
  FieldSTD = 0, FieldDG = 1
}
enum  eSelectionCategory { All = 0, Boundary, Cutted }
enum  { vtxTriangle = 0, vtxQuad, vtxEdge, vtxAll }
enum  MouseMode { MOUSE_NONE, MOUSE_ROTATE, MOUSE_TRANSLATE, MOUSE_ZOOM }
enum  TypeOfRenderer {
  Wireframe = 0, WireframeSlice, ColorMap, ColorMapSlice,
  ColorMapStd, ColorMapStdSlice, ColorMapBar, Totall
}
enum  RenderGLTypes {
  WIREFRAME_GL, WIREFRAME_CUTS_GL, COLORMAP_GL, COLORMAP_CUTS_GL,
  COLORMAP_BAR, NUM_DRAWS
}
enum  VertexType { INSIDE_SHAPE = 0, EDGE_SHAPE = (1 << 0), CORNER_SHAPE = (1 << 1) }
enum  { HORIZONTAL = 0, VERTICAL }

Functions

int create_grid (double targetoccupancy, uint32_t numelems, const BBox3D &gbox, const BBox3D *boxes, cl_int **griddata, cl_int **tridata, gridinfo_t *gridinfo)
int run_application (int argc, char **argv, bool initgl, Thread *parent=nullptr)
BBox3D operator* (const Matrix< float > &pMatrix, const BBox3D &pBBox3D)
BBox3D getModelBoundingBox (void)
const BBox3D & getModelBoundingBoxd_omp (Mesh *pmesh)
void min_sub_tab (long start_point, long n_points, double *l_mnmx)
template<typename T >
T degtorad (const T &angle)
std::ostream & operator<< (std::ostream &os, const HSV hsv)
std::ostream & operator<< (std::ostream &os, const ColorRGB &rhs)
ColorRGB ConvertHSVToRGB (const ColorHSV &hsv)
ColorHSV ConvertRGBToHSV (const ColorRGB &rgb)
template<class C >
C bilinearInterpolate1 (const double &s, const double &t, const C &a, const C &b, const C &c, const C &d)
template<typename T >
bool compare_func (T *it1, T *it2)
 FV_STATIC_ASSERT (ElemInfo, 8)
const pixel_descr_t * getPixelFormatDescriptor (const int id)
template<typename TReal = CoordType>
bool intersectTriangle (const Ray< TReal > &r, const Vec3< TReal > &v0, const Vec3< TReal > &v1, const Vec3< TReal > &v2, TReal tuv[])
template<typename TReal = CoordType>
bool intersectQuad (const Ray< TReal > &r, const Vec3< TReal > &v0, const Vec3< TReal > &v1, const Vec3< TReal > &v2, const Vec3< TReal > &v3, TReal tuv[])
template<typename TCore >
RenderManager< TCore > & RenderManagerInst (void)
void log (const int level, const char *msg,...)
template<typename T >
std::ostream & operator<< (std::ostream &strm, const Matrix< T > &mt)
template<typename T >
Matrix< T > operator* (T lhs, const Matrix< T > &rhs)
template<typename T >
Matrix< T > operator* (const Matrix< T > &lhs, T rhs)
template<typename T >
std::istream & operator>> (std::istream &lhs, Matrix< T > &transformation)
std::ostream & operator<< (std::ostream &os_, const BaseHandle &rhs_)
template<>
bool Model::InitModelObj< Model::MeshObj > (MeshObj &ref_)
template<>
bool Model::InitModelObj< Model::FieldObj > (FieldObj &ref_)
ModelCtrl & ModelCtrlInst (void)
int init_data ()
 static_assert ((sizeof(BaseParams)==(sizeof(float)*184)&&std::is_standard_layout< BaseParams >::value),"BaseParams does not satisfy contiguous storage requirements")
std::ostream & operator<< (std::ostream &os, const BaseParams &rhs)
Vec3D operator* (const Vec3D &vec_, const float rhv_)
Vec3D operator* (const float lhv_, const Vec3D &vec_)
Vec3D operator/ (const Vec3D &vec_, const float rhv_)
Vec3D operator% (const Vec3D &vec_1, const Vec3D &vec_2)
float dotProd (const Vec3D &vec_1, const Vec3D &vec_2)
ViewManager & ViewManagerInst (void)
bool initGLLists ()
GLuint createGLLists (const GLuint type, int size)
int init_platorm (int argc, char **argv)
int init_data (int argc, char **argv)
BBox3D ExtractAxisAlignedMeshExtens (const Mesh *mesh_ptr, int do_parallel)
size_t ExtractAxisAlignedElementExtens (const Mesh *mesh_ptr, std::vector< BBox3D > &elem_bboxes, int do_parallel)
int CalculateMinMaxValues (const Mesh *mesh_ptr, const Field *field_ptr, const int ctrl, double *&min_max_array)
int create_grid (double targetoccupancy, const uint32_t numelems, const BBox3D &gbox, const BBox3D *boxes, int **griddata, int **eldata, grid_t *gridinfo)
template<typename T >
ELVIS_DEVICE bool Subset (const Interval< T > &a, const Interval< T > &b)
template<typename T >
ELVIS_DEVICE Interval< T > fabs (const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator+ (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator/ (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator/ (const Interval< T > &lhs, const double &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator/ (const Interval< T > &lhs, const float &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator/ (const double &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator/ (const float &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE void Divide (const Interval< T > &lhs, const Interval< T > &rhs, Interval< T > &out1, Interval< T > &out2)
template<typename T >
ELVIS_DEVICE void Divide (const T &lhs, const Interval< T > &rhs, Interval< T > &out1, Interval< T > &out2)
template<typename T >
ELVIS_DEVICE void Divide (const Interval< T > &lhs, const T &rhs, Interval< T > &out1, Interval< T > &out2)
template<typename T >
ELVIS_DEVICE Interval< T > operator+ (const Interval< T > &lhs, const double &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator+ (const double &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator+ (const Interval< T > &lhs, const float &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator+ (const float &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator- (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator- (const Interval< T > &lhs, const float &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator- (const Interval< T > &lhs, const double &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator- (const float &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator- (const double &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator- (const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator* (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator* (const Interval< T > &lhs, const double &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator* (const double &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator* (const Interval< T > &lhs, const float &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > operator* (const float &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE bool Overlaps (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > Intersection (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > Union (const Interval< T > &lhs, const Interval< T > &rhs)
template<typename T >
ELVIS_DEVICE Interval< T > exp (const Interval< T > &rhs)
template<typename T >
std::ostream & operator<< (std::ostream &os, const Interval< T > &interval)
BBox3D operator* (const BBox3D &pBBox3D, const float zoom)
std::ostream & operator<< (std::ostream &os, const BBox3D &pBBox)
std::ostream & operator<< (std::ostream &os, const CutPlane &rhs)
template<typename T >
T mark_edges_in_triangle (int s, int u, const int dim)
template<typename T >
T mark_edges_in_quad (int s, int u, const int s_dim, const int u_dim)
bool initGLLists (const GLsizei size)
 m_dirty (false)
 if (!res) throw fv_exception("Can't load shaders for color map rendering!")
else m_program Complete ()
 m_program ()
 m_num_tri_faces (0)
 m_dispLists ({0, 0})
template<class Container >
void scanForClosest (Container &pContainer, SimplificationPoint *pIterSPBegin, SimplificationPoint *pIterSPEnd)
Vec3D operator- (const Vec3D &vec_)
bool operator== (const Vec3D &vec_1, const Vec3D &vec_2)
bool operator!= (const Vec3D &vec_1, const Vec3D &vec_2)
void deleteGLList (const GLuint type, const int size)
template<typename T >
bool OnList (const std::vector< T > &List, const T &val)
template<class Container , class Vertices >
void scanForClosest (Container &pContainer, SimplificationPoint *pIterSPBegin, SimplificationPoint *pIterSPEnd, const Vertices &aVertices)
bool operator< (const Vertex &a, const Vertex &b)

Variables

const BBox3D::Edge edges []
const pixel_descr_t pixel_descriptors []
uint64_t numRayTrianglesTests = 0
uint64_t numRayTrianglesIsect = 0
const int MeshKey = 0
const int FieldKey = 1
tagStrDict ShaderDictionary []
GLuint g_GLList
uint64_t numRayVolumeTests = 0
const char FieldType [] = {'s','c','t','m'}
const char * path = GLShader::GetPath(TRI_VERT)
bool res = m_program.AddShader(GLShader::GetPath(TRI_VERT),GL_VERTEX_SHADER)
 mfp_log_debug("GEOMETRY PATH: %s",path);
const int MAX_LOG_STRING = 1024
int64_t uniqueRayId = 0
shader_srcs g_shaders [SH_ALL]
const double XlocPrizm [18]
const double XlocTetra [12]

Typedef Documentation

typedef AAbb<double> FemViewer::AAbbd
typedef AAbb<float> FemViewer::AAbbf
typedef Win::MainApp FemViewer::AppEngine
typedef struct FemViewer::colormap_value FemViewer::colormap_value
typedef void(VtxAccumulator::* FemViewer::drawMethod)(const RenderParams &)
typedef enum FemViewer::RenderGLTypes FemViewer::gl_object_type
typedef enum FemViewer::eRenderType FemViewer::glsl_program_type
typedef WxGUI::wxFemViewerApp FemViewer::GUIEngine
typedef Matrix<double> FemViewer::Matrixd
typedef Matrix<float> FemViewer::Matrixf
typedef struct FemViewer::_Node_t FemViewer::Node_t
typedef enum FemViewer::TypeOfRenderer FemViewer::object_type
typedef BaseVertex FemViewer::Origin
typedef struct FemViewer::pixel_descr_t * FemViewer::pixel_descrptr_t

Enumeration Type Documentation

anonymous enum
Enumerator:
left 
up 
anonymous enum
Enumerator:
flat 
gradient 
anonymous enum
Enumerator:
EDGE_RENDERER 
TRIANGLE_RENDERER 
TRAINGLE_STRIP_RENDERER 
anonymous enum
Enumerator:
NOWERE 
LOGCONSOLE 
LOGFILE 
LOGDIALOG 
LOGEXTERNAL 
anonymous enum
Enumerator:
vtxTriangle 
vtxQuad 
vtxEdge 
vtxAll 
anonymous enum
Enumerator:
HORIZONTAL 
VERTICAL 
enum FemViewer::ApproximationType
Enumerator:
LINEAR 
HIGH_ORDER 
enum FemViewer::BaseType
Enumerator:
TENSOR 
COMPLETE 
enum FemViewer::CoreType
Enumerator:
ALONE 
MASTER 
SLAVE 
COUNT 
enum FemViewer::ElemType
Enumerator:
REFIN 
FREE 
PRIZM 
BRICK 
TETRA 
enum FemViewer::eLevel
Enumerator:
LogERROR 
LogWARNING 
LogINFO 
LogDEBUG 
LogDEBUG1 
enum FemViewer::ePixelFormat
Enumerator:
PF_UNKNOWN 
PF_R8 
PF_RG8 
PF_RGB8 
PF_RGBA8 
PF_RGBA8_SRGB 
PF_BGRA8_SRGB 
PF_ALL 
enum FemViewer::eRenderType
Enumerator:
SH_UNKNOWN 
SH_EDGE 
SH_TRIANGLE 
SH_TRIANGLE_STRIP 
SH_ALL 
enum FemViewer::eSelectionCategory
Enumerator:
All 
Boundary 
Cutted 
enum FemViewer::eShaderType
Enumerator:
SH_VERTEX 
SH_GEOMETRY 
SH_FRAGMENT 
SH_TESELATOR 
SH_COMPUTE 
enum FemViewer::FaceType
Enumerator:
F_TRIA 
F_QUAD 
enum FemViewer::GLListType
Enumerator:
NUM_VERTICES_LIST_WIREFRAME 
NUM_ELEMENTS_LIST_WIREFRAME 
NUM_VERTICES_LIST_COLORMAP 
NUM_ELEMENTS_LIST_COLORMAP 
NUM_VERTICES_LIST_CUTTED_WIREFRAME 
NUM_ELEMENTS_LIST_CUTTED_WIREFRAME 
NUM_VERTICES_LIST_CUTTED_COLORMAP 
NUM_ELEMENTS_LIST_CUTTED_COLORMAP 
COLORBAR_LIST0 
COLORBAR_LIST1 
COLORBAR_LIST2 
ID_COLORMAP_TEXT 
ID_GRID 
ID_AXES 
NUM_TOTAL_LISTS 
enum FemViewer::glslshader_type
Enumerator:
EDGE_VERT 
EDGE_FRAG 
TRI_VERT 
TRI_GEOM 
TRI_FRAG 
TRISTRIP_GEOM 
enum FemViewer::HandleType
Enumerator:
Unknown 
MeshPrizm 
MeshHybrid 
MeshRemesh 
FieldSTD 
FieldDG 
enum FemViewer::InstantType
Enumerator:
MODULE 
APPLICATION 
enum FemViewer::LegendType
Enumerator:
SOLID 
GRADIENT 
enum FemViewer::LegendValueType
Enumerator:
NON 
BORDER 
INSIDE 
OUTSIDE 
START 
END 
LVT_COLOR 
enum FemViewer::ModuleType
Enumerator:
INTERNAL 
EXTERNAL 
enum FemViewer::MouseMode
Enumerator:
MOUSE_NONE 
MOUSE_ROTATE 
MOUSE_TRANSLATE 
MOUSE_ZOOM 
enum FemViewer::RefinementType
Enumerator:
NOT_REF 
REF_ISO 
enum FemViewer::Render_t
Enumerator:
RASTERIZATION_GL 
RAYTRACE_GL_CL 
enum FemViewer::RenderCore
Enumerator:
CORE_GL 
CORE_OPENCL 
enum FemViewer::RenderGLTypes
Enumerator:
WIREFRAME_GL 
WIREFRAME_CUTS_GL 
COLORMAP_GL 
COLORMAP_CUTS_GL 
COLORMAP_BAR 
NUM_DRAWS 
enum FemViewer::tf_chanel_t
Enumerator:
eDensity 
eRed 
eGreen 
eBlue 
enum FemViewer::TypeOfRenderer
Enumerator:
Wireframe 
WireframeSlice 
ColorMap 
ColorMapSlice 
ColorMapStd 
ColorMapStdSlice 
ColorMapBar 
Totall 
enum FemViewer::VertexType
Enumerator:
INSIDE_SHAPE 
EDGE_SHAPE 
CORNER_SHAPE 

Function Documentation

template<class C >
C FemViewer::bilinearInterpolate1 ( const double &  s,
const double &  t,
const C &  a,
const C &  b,
const C &  c,
const C &  d 
) [inline]
int FemViewer::CalculateMinMaxValues ( const Mesh *  mesh_ptr,
const Field *  field_ptr,
const int  ctrl,
double *&  min_max_array 
)

Here is the call graph for this function:

template<typename T >
bool FemViewer::compare_func ( T *  it1,
T *  it2 
) [inline]
else m_program FemViewer::Complete (  ) 
ColorRGB FemViewer::ConvertHSVToRGB ( const ColorHSV &  hsv  ) 

Here is the call graph for this function:

Here is the caller graph for this function:

ColorHSV FemViewer::ConvertRGBToHSV ( const ColorRGB &  rgb  ) 

Here is the caller graph for this function:

int FemViewer::create_grid ( double  targetoccupancy,
const uint32_t  numelems,
const BBox3D &  gbox,
const BBox3D *  boxes,
int **  griddata,
int **  eldata,
grid_t *  gridinfo 
)

Here is the call graph for this function:

int FemViewer::create_grid ( double  targetoccupancy,
uint32_t  numelems,
const BBox3D &  gbox,
const BBox3D *  boxes,
cl_int **  griddata,
cl_int **  tridata,
gridinfo_t *  gridinfo 
)

Here is the call graph for this function:

Here is the caller graph for this function:

GLuint FemViewer::createGLLists ( const GLuint  type,
int  size 
)

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename T >
T FemViewer::degtorad ( const T &  angle  )  [inline]

Here is the caller graph for this function:

void FemViewer::deleteGLList ( const GLuint  type,
const int  size 
)

Here is the caller graph for this function:

template<typename T >
ELVIS_DEVICE void FemViewer::Divide ( const Interval< T > &  lhs,
const T &  rhs,
Interval< T > &  out1,
Interval< T > &  out2 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE void FemViewer::Divide ( const T &  lhs,
const Interval< T > &  rhs,
Interval< T > &  out1,
Interval< T > &  out2 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE void FemViewer::Divide ( const Interval< T > &  lhs,
const Interval< T > &  rhs,
Interval< T > &  out1,
Interval< T > &  out2 
) [inline]

Here is the call graph for this function:

Here is the caller graph for this function:

float FemViewer::dotProd ( const Vec3D &  vec_1,
const Vec3D &  vec_2 
) [inline]
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::exp ( const Interval< T > &  rhs  )  [inline]

Here is the call graph for this function:

Here is the caller graph for this function:

size_t FemViewer::ExtractAxisAlignedElementExtens ( const Mesh *  mesh_ptr,
std::vector< BBox3D > &  elem_bboxes,
int  do_parallel 
)

Here is the call graph for this function:

BBox3D FemViewer::ExtractAxisAlignedMeshExtens ( const Mesh *  mesh_ptr,
int  do_parallel 
)

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::fabs ( const Interval< T > &  rhs  )  [inline]

Here is the call graph for this function:

FemViewer::FV_STATIC_ASSERT ( ElemInfo  ,
8   
)
BBox3D FemViewer::getModelBoundingBox ( void   ) 

Here is the call graph for this function:

const BBox3D& FemViewer::getModelBoundingBoxd_omp ( Mesh *  pmesh  ) 
const pixel_descr_t* FemViewer::getPixelFormatDescriptor ( const int  id  )  [inline]

Here is the caller graph for this function:

FemViewer::if ( !  res  ) 

Here is the caller graph for this function:

int FemViewer::init_data ( int  argc,
char **  argv 
)
int FemViewer::init_data (  ) 
int FemViewer::init_platorm ( int  argc,
char **  argv 
)
bool FemViewer::initGLLists ( const GLsizei  size  ) 
bool FemViewer::initGLLists (  ) 
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::Intersection ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename TReal = CoordType>
bool FemViewer::intersectQuad ( const Ray< TReal > &  r,
const Vec3< TReal > &  v0,
const Vec3< TReal > &  v1,
const Vec3< TReal > &  v2,
const Vec3< TReal > &  v3,
TReal  tuv[] 
) [inline]

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename TReal = CoordType>
bool FemViewer::intersectTriangle ( const Ray< TReal > &  r,
const Vec3< TReal > &  v0,
const Vec3< TReal > &  v1,
const Vec3< TReal > &  v2,
TReal  tuv[] 
) [inline]

Here is the call graph for this function:

Here is the caller graph for this function:

void FemViewer::log ( const int  level,
const char *  msg,
  ... 
)

Here is the call graph for this function:

Here is the caller graph for this function:

FemViewer::m_dirty ( false   ) 

Here is the call graph for this function:

Here is the caller graph for this function:

FemViewer::m_dispLists (  ) 

Here is the caller graph for this function:

FemViewer::m_num_tri_faces ( 0   ) 

Here is the caller graph for this function:

FemViewer::m_program (  ) 

Here is the caller graph for this function:

template<typename T >
T FemViewer::mark_edges_in_quad ( int  s,
int  u,
const int  s_dim,
const int  u_dim 
) [inline]
template<typename T >
T FemViewer::mark_edges_in_triangle ( int  s,
int  u,
const int  dim 
) [inline]
void FemViewer::min_sub_tab ( long  start_point,
long  n_points,
double *  l_mnmx 
)

Here is the call graph for this function:

template<>
bool FemViewer::Model::InitModelObj< Model::FieldObj > ( FieldObj &  ref_  )  [inline]
template<>
bool FemViewer::Model::InitModelObj< Model::MeshObj > ( MeshObj &  ref_  )  [inline]
ModelCtrl & FemViewer::ModelCtrlInst ( void   ) 

Here is the caller graph for this function:

template<typename T >
bool FemViewer::OnList ( const std::vector< T > &  List,
const T &  val 
) [inline]
bool FemViewer::operator!= ( const Vec3D &  vec_1,
const Vec3D &  vec_2 
)
Vec3D FemViewer::operator% ( const Vec3D &  vec_1,
const Vec3D &  vec_2 
) [inline]
BBox3D FemViewer::operator* ( const BBox3D &  pBBox3D,
const float  zoom 
)
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator* ( const float &  lhs,
const Interval< T > &  rhs 
) [inline]
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator* ( const Interval< T > &  lhs,
const float &  rhs 
) [inline]
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator* ( const double &  lhs,
const Interval< T > &  rhs 
) [inline]
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator* ( const Interval< T > &  lhs,
const double &  rhs 
) [inline]
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator* ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

Vec3D FemViewer::operator* ( const float  lhv_,
const Vec3D &  vec_ 
) [inline]
Vec3D FemViewer::operator* ( const Vec3D &  vec_,
const float  rhv_ 
) [inline]
template<typename T >
Matrix<T> FemViewer::operator* ( const Matrix< T > &  lhs,
T  rhs 
) [inline]
template<typename T >
Matrix<T> FemViewer::operator* ( T  lhs,
const Matrix< T > &  rhs 
) [inline]
BBox3D FemViewer::operator* ( const Matrix< float > &  pMatrix,
const BBox3D &  pBBox3D 
)
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator+ ( const float &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator+ ( const Interval< T > &  lhs,
const float &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator+ ( const double &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator+ ( const Interval< T > &  lhs,
const double &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator+ ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

Vec3D FemViewer::operator- ( const Vec3D &  vec_  ) 
template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator- ( const Interval< T > &  rhs  )  [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator- ( const double &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator- ( const float &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator- ( const Interval< T > &  lhs,
const double &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator- ( const Interval< T > &  lhs,
const float &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator- ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator/ ( const float &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator/ ( const double &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator/ ( const Interval< T > &  lhs,
const float &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator/ ( const Interval< T > &  lhs,
const double &  rhs 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::operator/ ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

Vec3D FemViewer::operator/ ( const Vec3D &  vec_,
const float  rhv_ 
) [inline]
bool FemViewer::operator< ( const Vertex &  a,
const Vertex &  b 
) [inline]

Here is the call graph for this function:

std::ostream& FemViewer::operator<< ( std::ostream &  os,
const CutPlane &  rhs 
)

Here is the call graph for this function:

std::ostream& FemViewer::operator<< ( std::ostream &  os,
const BBox3D &  pBBox 
)

Here is the call graph for this function:

template<typename T >
std::ostream& FemViewer::operator<< ( std::ostream &  os,
const Interval< T > &  interval 
) [inline]

Here is the call graph for this function:

std::ostream& FemViewer::operator<< ( std::ostream &  os,
const BaseParams &  rhs 
) [inline]
std::ostream & FemViewer::operator<< ( std::ostream &  os_,
const BaseHandle &  rhs_ 
) [inline]
template<typename T >
std::ostream & FemViewer::operator<< ( std::ostream &  strm,
const Matrix< T > &  mt 
) [inline]
std::ostream& FemViewer::operator<< ( std::ostream &  os,
const ColorRGB &  rhs 
) [inline]
std::ostream& FemViewer::operator<< ( std::ostream &  os,
const HSV  hsv 
) [inline]
bool FemViewer::operator== ( const Vec3D &  vec_1,
const Vec3D &  vec_2 
)
template<typename T >
std::istream& FemViewer::operator>> ( std::istream &  lhs,
Matrix< T > &  transformation 
) [inline]
template<typename T >
ELVIS_DEVICE bool FemViewer::Overlaps ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

template<typename TCore >
RenderManager<TCore>& FemViewer::RenderManagerInst ( void   )  [inline]
int FemViewer::run_application ( int  argc,
char **  argv,
bool  initgl,
Thread *  parent = nullptr 
)

Here is the call graph for this function:

Here is the caller graph for this function:

template<class Container , class Vertices >
void FemViewer::scanForClosest ( Container &  pContainer,
SimplificationPoint *  pIterSPBegin,
SimplificationPoint *  pIterSPEnd,
const Vertices &  aVertices 
) [inline]

Here is the call graph for this function:

template<class Container >
void FemViewer::scanForClosest ( Container &  pContainer,
SimplificationPoint *  pIterSPBegin,
SimplificationPoint *  pIterSPEnd 
) [inline]

Here is the call graph for this function:

FemViewer::static_assert ( (sizeof(BaseParams)==(sizeof(float)*184)&&std::is_standard_layout< BaseParams >::value)  ,
"BaseParams does not satisfy contiguous storage requirements"   
)
template<typename T >
ELVIS_DEVICE bool FemViewer::Subset ( const Interval< T > &  a,
const Interval< T > &  b 
) [inline]

Here is the call graph for this function:

template<typename T >
ELVIS_DEVICE Interval<T> FemViewer::Union ( const Interval< T > &  lhs,
const Interval< T > &  rhs 
) [inline]

Here is the call graph for this function:

ViewManager & FemViewer::ViewManagerInst ( void   ) 

Here is the caller graph for this function:

Variable Documentation

const BBox3D::Edge FemViewer::edges
Initial value:
 {
        BBox3D::Edge(0, 1),
        
        BBox3D::Edge(1, 2),
        
        BBox3D::Edge(2, 3),
        
        BBox3D::Edge(0, 3),
        BBox3D::Edge(0, 4),
        BBox3D::Edge(1, 5),
        
        BBox3D::Edge(2, 6),
        
        BBox3D::Edge(3, 7),
        BBox3D::Edge(4, 5),
        
        BBox3D::Edge(5, 6),
        
        BBox3D::Edge(7, 6),
        
        BBox3D::Edge(4, 7)
}
const int FemViewer::FieldKey = 1
const char FemViewer::FieldType = {'s','c','t','m'}
GLuint FemViewer::g_GLList
shader_srcs FemViewer::g_shaders[SH_ALL]
Initial value:
 {
    
    {
    "shEdge.vert",
    nullptr,
    "shEdge.frag"
    },
    
    {
    "shTriVGF.vert",
    "shTriVGF.geom",
    "shTriVGF.frag"
    },
    
    {
    "shTriVGF.vert",
    "shTriStripVGF.geom",
    "shTriVGF.frag"
    }
}
const int FemViewer::MAX_LOG_STRING = 1024
const int FemViewer::MeshKey = 0
uint64_t FemViewer::numRayTrianglesIsect = 0
uint64_t FemViewer::numRayTrianglesTests = 0
uint64_t FemViewer::numRayVolumeTests = 0
FemViewer::path = GLShader::GetPath(TRI_VERT)
const pixel_descr_t FemViewer::pixel_descriptors
Initial value:
 {
  { 0, },
  { GL_R8,GL_RED,GL_UNSIGNED_BYTE,1,1,true,0,"PF_R8",false },
  { GL_RG8,GL_RG,GL_UNSIGNED_BYTE,2,2,true,0,"PF_RG8",false },
  { GL_RGB8,GL_RGB,GL_UNSIGNED_BYTE,3,3,true,0,"PF_RGB8",false },
  { GL_RGBA8,GL_RGBA,GL_UNSIGNED_INT_8_8_8_8,4,4,true,PF_RGBA8_SRGB,"PF_RGBA8",false},


  { GL_SRGB8_ALPHA8,GL_RGBA,GL_UNSIGNED_BYTE,4,4,true,0,"PF_RGBA8_SRGB",false },
  { GL_SRGB8_ALPHA8,GL_BGRA,GL_UNSIGNED_BYTE,4,4,true,0,"PF_BGRA8_SRGB",false }
}
FemViewer::res = m_program.AddShader(GLShader::GetPath(TRI_VERT),GL_VERTEX_SHADER)

mfp_log_debug("GEOMETRY PATH: %s",path);

StrDict FemViewer::ShaderDictionary
Initial value:
 {
        {EDGE_VERT, shader_files[0]},
        {EDGE_FRAG, shader_files[1]},
        {TRI_VERT, shader_files[2]},
        {TRI_GEOM, shader_files[3]},
        {TRI_FRAG, shader_files[4]},
        {TRISTRIP_GEOM, shader_files[5]}
}
int64_t FemViewer::uniqueRayId = 0
const double FemViewer::XlocPrizm[18]
Initial value:
 {
                0.0, 0.0, -1.0,
                1.0, 0.0, -1.0,
                0.0, 1.0, -1.0,
                0.0, 0.0,  1.0,
                1.0, 0.0,  1.0,
                0.0, 1.0,  1.0
    }
const double FemViewer::XlocTetra[12]
Initial value:
 {
                1.0, 0.0, 0.0,
                0.0, 1.0, 0.0,
                0.0, 0.0, 1.0,
                0.0, 0.0, 0.0,
    }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
Generated on 3 Jun 2020 for ModFEM by  doxygen 1.6.1