cgma
Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Attributes
GfxDebug Class Reference

#include <GfxDebug.hpp>

List of all members.

Public Member Functions

 GfxDebug ()
virtual ~GfxDebug ()

Static Public Member Functions

static bool is_initialized ()
static void clear ()
static void display_all (bool flush_highlight=true, bool import_mesh_display=false)
static void clear_highlight ()
static void drawing_mode (int mode)
static int create_window ()
static void delete_window (int window_id)
static void set_2D_mode (int window_id)
static void flush ()
static void mouse_xforms ()
static void display_to_world_length (double pixels, double &length)
static void draw_ref_entity (RefEntity *entity, int color=CUBIT_DEFAULT_COLOR_INDEX, CubitTransformMatrix *trans_mat=0)
static void draw_ref_vertex (RefVertex *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_ref_edge (RefEdge *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_ref_face (RefFace *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_ref_face_edges (RefFace *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_ref_volume (RefVolume *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_ref_body (Body *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void highlight_ref_vertex (RefVertex *entity)
static void highlight_ref_edge (RefEdge *entity)
static void highlight_ref_face (RefFace *entity)
static void highlight_ref_volume (RefVolume *entity)
static void highlight_ref_body (Body *entity)
static void draw_mref_entity (MRefEntity *entity, int color=CUBIT_DEFAULT_COLOR_INDEX, bool draw_geom=true, bool draw_mesh=true, CubitTransformMatrix *trans_mat=0)
static void draw_mref_vertex (MRefVertex *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_mref_edge (MRefEdge *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_mref_face (MRefFace *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_mref_volume (MRefVolume *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_mref_body (MBody *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_mref_entity_mesh (MRefEntity *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void draw_mref_volume_faces (MRefVolume *entity, int color=CUBIT_DEFAULT_COLOR_INDEX)
static void highlight_mref_vertex (MRefVertex *entity)
static void highlight_mref_edge (MRefEdge *entity)
static void highlight_mref_face (MRefFace *entity)
static void highlight_mref_volume (MRefVolume *entity)
static void highlight_mref_body (MBody *entity)
static void draw_nodes (DLIList< CubitNode * > *entities, int color)
static void draw_edges (DLIList< CubitEdge * > *entities, int color)
static void draw_quads (DLIList< CubitFace * > *entities, int color)
static void draw_tris (DLIList< CubitTri * > *entities, int color)
static void draw_tets (DLIList< CubitTet * > *entities, int color)
static void draw_hexes (DLIList< CubitHex * > *entities, int color)
static void draw_wedges (DLIList< CubitWedge * > *entities, int color)
static void draw_mesh_entity (MeshEntity *entity, int color)
static void draw_node (CubitNode *entity, int color)
static void draw_edge (CubitEdge *entity, int color)
static void draw_quad (CubitFace *entity, int color)
static void draw_tri (CubitTri *entity, int color)
static void draw_tet (CubitTet *entity, int color)
static void draw_hex (CubitHex *entity, int color)
static void draw_pyramid (CubitPyramid *entity, int color)
static void draw_wedge (CubitWedge *entity, int color)
static void highlight_node (CubitNode *entity)
static void highlight_edge (CubitEdge *entity)
static void highlight_quad (CubitFace *entity)
static void highlight_tri (CubitTri *entity)
static void highlight_tet (CubitTet *entity)
static void highlight_hex (CubitHex *entity)
static void highlight_pyramid (CubitPyramid *entity)
static void highlight_wedge (CubitWedge *entity)
static void draw_facet (CubitFacet *facet, int color, int draw_uv=0)
static void draw_facet_edge (CubitFacetEdge *facet_edge, int color)
static void draw_geotet (GeoTet *tet, int color)
static void draw_geonode (GeoNode *node, int color)
static void draw_box (CubitBox &box, int color)
static void draw_point (float x, float y, float z, int color)
static void draw_point (const CubitVector &vector, int color)
static void draw_point (CubitVector *vector, int color)
static void draw_points (DLIList< CubitVector > &points, int color)
static void draw_line (float x1, float y1, float z1, float x2, float y2, float z2, int color)
static void draw_line (const CubitVector &x, const CubitVector &y, int color)
static void draw_polyline (const GPoint *points, int num_points, int color)
static void draw_polygon (const GPoint *points, int num_points, int color, int border_color, bool filled=true)
static void draw_quad (const GPoint *points, int color)
static void draw_tri (const GPoint *points, int color)
static void draw_vector (const GPoint *tail, const GPoint *head, int color)
static void draw_vector (const CubitVector &tail, const CubitVector &head, int color)
static void draw_shell (int num_pts, const GPoint *points, int num_faces, const int *face_list, int color)
static void draw_shell (int num_pts, const GPoint *points, int num_faces, const int *face_list, const int *colors)
static void draw_label (const char *label, float x, float y, float z, int color)
static void draw_label (int label, float x, float y, float z, int color)
static void zoom (CubitBox &box)
static void highlight_points (int num_points, const double *xyzs)
static void highlight_polylines (int num_points, const double *xyzs, int num_line_points, const int *line_list)
static void highlight_polygons (int num_points, const double *xyzs, int num_face_points, const int *face_list)
static void draw_surface (Surface *surf, int color)

Protected Member Functions

virtual void p_clear ()=0
virtual void p_display_all (bool, bool)=0
virtual void p_clear_highlight ()=0
virtual void p_drawing_mode (int)=0
virtual int p_create_window ()=0
virtual void p_delete_window (int)=0
virtual void p_set_2D_mode (int)=0
virtual void p_flush ()=0
virtual void p_mouse_xforms ()=0
virtual void p_display_to_world_length (double pixels, double &length)=0
virtual void p_draw_ref_entity (RefEntity *entity, int color, CubitTransformMatrix *mat)=0
virtual void p_draw_ref_vertex (RefVertex *entity, int color)=0
virtual void p_draw_ref_edge (RefEdge *entity, int color)=0
virtual void p_draw_ref_face (RefFace *entity, int color)=0
virtual void p_draw_ref_face_edges (RefFace *entity, int color)=0
virtual void p_draw_ref_volume (RefVolume *entity, int color)=0
virtual void p_draw_ref_body (Body *entity, int color)=0
virtual void p_draw_mref_entity (MRefEntity *entity, int color, bool geom, bool mesh, CubitTransformMatrix *mat)=0
virtual void p_draw_mref_vertex (MRefVertex *entity, int color)=0
virtual void p_draw_mref_edge (MRefEdge *entity, int color)=0
virtual void p_draw_mref_face (MRefFace *entity, int color)=0
virtual void p_draw_mref_volume (MRefVolume *entity, int color)=0
virtual void p_draw_mref_body (MBody *entity, int color)=0
virtual void p_draw_mref_entity_mesh (MRefEntity *entity, int color)=0
virtual void p_draw_mref_volume_faces (MRefVolume *entity, int color)=0
virtual void p_highlight_ref_vertex (RefVertex *entity)=0
virtual void p_highlight_ref_edge (RefEdge *entity)=0
virtual void p_highlight_ref_face (RefFace *entity)=0
virtual void p_highlight_ref_volume (RefVolume *entity)=0
virtual void p_highlight_ref_body (Body *entity)=0
virtual void p_highlight_mref_vertex (MRefVertex *entity)=0
virtual void p_highlight_mref_edge (MRefEdge *entity)=0
virtual void p_highlight_mref_face (MRefFace *entity)=0
virtual void p_highlight_mref_volume (MRefVolume *entity)=0
virtual void p_highlight_mref_body (MBody *entity)=0
virtual void p_draw_nodes (DLIList< CubitNode * > *, int)=0
virtual void p_draw_edges (DLIList< CubitEdge * > *, int)=0
virtual void p_draw_quads (DLIList< CubitFace * > *, int)=0
virtual void p_draw_tris (DLIList< CubitTri * > *, int)=0
virtual void p_draw_tets (DLIList< CubitTet * > *, int)=0
virtual void p_draw_hexes (DLIList< CubitHex * > *, int)=0
virtual void p_draw_wedges (DLIList< CubitWedge * > *, int)=0
virtual void p_draw_mesh_entity (MeshEntity *, int)=0
virtual void p_draw_node (CubitNode *, int)=0
virtual void p_draw_edge (CubitEdge *, int)=0
virtual void p_draw_quad (CubitFace *, int)=0
virtual void p_draw_tri (CubitTri *, int)=0
virtual void p_draw_tet (CubitTet *, int)=0
virtual void p_draw_hex (CubitHex *, int)=0
virtual void p_draw_pyramid (CubitPyramid *, int)=0
virtual void p_draw_wedge (CubitWedge *, int)=0
virtual void p_highlight_node (CubitNode *entity)=0
virtual void p_highlight_edge (CubitEdge *entity)=0
virtual void p_highlight_quad (CubitFace *entity)=0
virtual void p_highlight_tri (CubitTri *entity)=0
virtual void p_highlight_tet (CubitTet *entity)=0
virtual void p_highlight_hex (CubitHex *entity)=0
virtual void p_highlight_pyramid (CubitPyramid *entity)=0
virtual void p_highlight_wedge (CubitWedge *entity)=0
virtual void p_draw_facet (CubitFacet *, int, int)=0
virtual void p_draw_facet_edge (CubitFacetEdge *, int)=0
virtual void p_draw_geotet (GeoTet *, int)=0
virtual void p_draw_geonode (GeoNode *, int)=0
virtual void p_draw_box (CubitBox &box, int color)=0
virtual void p_draw_point (float, float, float, int)=0
virtual void p_draw_point (const CubitVector &vector, int color)=0
virtual void p_draw_line (float, float, float, float, float, float, int)=0
virtual void p_draw_line (const CubitVector &x, const CubitVector &y, int color)=0
virtual void p_draw_polyline (const GPoint *, int, int)=0
virtual void p_draw_polygon (const GPoint *points, int num_points, int color, int border_color, bool filled)=0
virtual void p_draw_quad (const GPoint *, int)=0
virtual void p_draw_tri (const GPoint *, int)=0
virtual void p_draw_vector (const CubitVector &, const CubitVector &, int)=0
virtual void p_draw_shell (int, const GPoint *, int, const int *, int)=0
virtual void p_draw_shell (int, const GPoint *, int, const int *, const int *)=0
virtual void p_draw_label (const char *, float, float, float, int)=0
virtual void p_draw_label (int, float, float, float, int)=0
virtual void p_zoom (CubitBox &box)=0
virtual void p_highlight_points (int num_points, const double *xyzs)=0
virtual void p_highlight_polylines (int num_points, const double *xyzs, int num_line_points, const int *line_list)=0
virtual void p_highlight_polygons (int num_points, const double *xyzs, int num_face_points, const int *face_list)=0
virtual void p_draw_surface (Surface *surf, int color)=0

Static Protected Attributes

static GfxDebug * mInstance = 0

Detailed Description

Definition at line 54 of file GfxDebug.hpp.

Constructor & Destructor Documentation

GfxDebug::GfxDebug ( )

Definition at line 11 of file GfxDebug.cpp.

{
  if(mInstance)
  {
    assert(0);
    // if you want a new instance in place of a previous one,
    // delete the previous one first
  }
  mInstance = this;
}
GfxDebug::~GfxDebug ( ) [virtual]

Definition at line 22 of file GfxDebug.cpp.

{
  mInstance = 0;
}

Member Function Documentation

void GfxDebug::clear ( ) [static]

Definition at line 44 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_clear();
}
void GfxDebug::clear_highlight ( ) [static]

Definition at line 56 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_clear_highlight();
}
int GfxDebug::create_window ( ) [static]

Definition at line 80 of file GfxDebug.cpp.

{
  if(!mInstance) return -1;
  return mInstance->p_create_window();
}
void GfxDebug::delete_window ( int  window_id) [static]

Definition at line 87 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_delete_window(window_id);
}
void GfxDebug::display_all ( bool  flush_highlight = true,
bool  import_mesh_display = false 
) [static]

Definition at line 50 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_display_all(flush_highlight, import_mesh_display);
}
void GfxDebug::display_to_world_length ( double  pixels,
double &  length 
) [static]

Definition at line 115 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_display_to_world_length(pixels, length);
}
void GfxDebug::draw_box ( CubitBox &  box,
int  color 
) [static]

Definition at line 473 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_box(box, color);
}
void GfxDebug::draw_edge ( CubitEdge *  entity,
int  color 
) [static]

Definition at line 359 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_edge(entity, color);
}
void GfxDebug::draw_edges ( DLIList< CubitEdge * > *  entities,
int  color 
) [static]

Definition at line 310 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_edges(entities, color);
}
void GfxDebug::draw_facet ( CubitFacet *  facet,
int  color,
int  draw_uv = 0 
) [static]

Definition at line 447 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_facet(facet, color, draw_uv);
}
void GfxDebug::draw_facet_edge ( CubitFacetEdge *  facet_edge,
int  color 
) [static]

Definition at line 453 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_facet_edge(facet_edge, color);
}
void GfxDebug::draw_geonode ( GeoNode *  node,
int  color 
) [static]

Definition at line 465 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_geonode(node, color);
}
void GfxDebug::draw_geotet ( GeoTet *  tet,
int  color 
) [static]

Definition at line 459 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_geotet(tet, color);
}
void GfxDebug::draw_hex ( CubitHex *  entity,
int  color 
) [static]

Definition at line 379 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_hex(entity, color);
}
void GfxDebug::draw_hexes ( DLIList< CubitHex * > *  entities,
int  color 
) [static]

Definition at line 330 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_hexes(entities, color);
}
void GfxDebug::draw_label ( const char *  label,
float  x,
float  y,
float  z,
int  color 
) [static]

Definition at line 569 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_label(label, x, y, z, color);
}
void GfxDebug::draw_label ( int  label,
float  x,
float  y,
float  z,
int  color 
) [static]

Definition at line 574 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_label(label, x, y, z, color);
}
void GfxDebug::draw_line ( float  x1,
float  y1,
float  z1,
float  x2,
float  y2,
float  z2,
int  color 
) [static]

Definition at line 509 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_line(x1, y1, z1, x2, y2, z2, color);
}
void GfxDebug::draw_line ( const CubitVector &  x,
const CubitVector &  y,
int  color 
) [static]

Definition at line 515 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_line(x, y, color);
}
void GfxDebug::draw_mesh_entity ( MeshEntity *  entity,
int  color 
) [static]

Definition at line 348 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mesh_entity(entity, color);
}
void GfxDebug::draw_mref_body ( MBody *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 196 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_body(entity, color);
}
void GfxDebug::draw_mref_edge ( MRefEdge *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 178 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_edge(entity, color);
}
void GfxDebug::draw_mref_entity ( MRefEntity *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX,
bool  draw_geom = true,
bool  draw_mesh = true,
CubitTransformMatrix *  trans_mat = 0 
) [static]

Definition at line 166 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_entity(entity, color, draw_geom, draw_mesh, mat);
}
void GfxDebug::draw_mref_entity_mesh ( MRefEntity *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 202 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_entity_mesh(entity, color);
}
void GfxDebug::draw_mref_face ( MRefFace *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 184 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_face(entity, color);
}
void GfxDebug::draw_mref_vertex ( MRefVertex *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 172 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_vertex(entity, color);
}
void GfxDebug::draw_mref_volume ( MRefVolume *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 190 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_volume(entity, color);
}
void GfxDebug::draw_mref_volume_faces ( MRefVolume *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 208 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_mref_volume_faces(entity, color);
}
void GfxDebug::draw_node ( CubitNode *  entity,
int  color 
) [static]

Definition at line 354 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_node(entity, color);
}
void GfxDebug::draw_nodes ( DLIList< CubitNode * > *  entities,
int  color 
) [static]

Definition at line 305 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_nodes(entities, color);
}
void GfxDebug::draw_point ( float  x,
float  y,
float  z,
int  color 
) [static]

Definition at line 480 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_point(x, y, z, color);
}
void GfxDebug::draw_point ( const CubitVector &  vector,
int  color 
) [static]

Definition at line 486 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_point(vector, color);
}
void GfxDebug::draw_point ( CubitVector *  vector,
int  color 
) [static]

Definition at line 492 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_point(*vector, color);
}
void GfxDebug::draw_points ( DLIList< CubitVector > &  points,
int  color 
) [static]

Definition at line 498 of file GfxDebug.cpp.

{
    if (!mInstance) return;
    int i;
    for ( i = 0; i < points.size(); i++ )
    {
        mInstance->p_draw_point( points[i], color );
    }
}
void GfxDebug::draw_polygon ( const GPoint *  points,
int  num_points,
int  color,
int  border_color,
bool  filled = true 
) [static]

Definition at line 529 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_polygon(points, num_points, color, border_color, filled);
}
void GfxDebug::draw_polyline ( const GPoint *  points,
int  num_points,
int  color 
) [static]

Definition at line 522 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_polyline(points, num_points, color);
}
void GfxDebug::draw_pyramid ( CubitPyramid *  entity,
int  color 
) [static]

Definition at line 384 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_pyramid(entity, color);
}
void GfxDebug::draw_quad ( CubitFace *  entity,
int  color 
) [static]

Definition at line 364 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_quad(entity, color);
}
void GfxDebug::draw_quad ( const GPoint *  points,
int  color 
) [static]

Definition at line 536 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_quad(points, color);
}
void GfxDebug::draw_quads ( DLIList< CubitFace * > *  entities,
int  color 
) [static]

Definition at line 315 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_quads(entities, color);
}
void GfxDebug::draw_ref_body ( Body *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 159 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_body(entity, color);
}
void GfxDebug::draw_ref_edge ( RefEdge *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 135 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_edge(entity, color);
}
void GfxDebug::draw_ref_entity ( RefEntity *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX,
CubitTransformMatrix *  trans_mat = 0 
) [static]

Definition at line 123 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_entity(entity, color, mat);
}
void GfxDebug::draw_ref_face ( RefFace *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 141 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_face(entity, color);
}
void GfxDebug::draw_ref_face_edges ( RefFace *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 147 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_face_edges(entity, color);
}
void GfxDebug::draw_ref_vertex ( RefVertex *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 129 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_vertex(entity, color);
}
void GfxDebug::draw_ref_volume ( RefVolume *  entity,
int  color = CUBIT_DEFAULT_COLOR_INDEX 
) [static]

Definition at line 153 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_ref_volume(entity, color);
}
void GfxDebug::draw_shell ( int  num_pts,
const GPoint *  points,
int  num_faces,
const int *  face_list,
int  color 
) [static]

Definition at line 562 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_shell(num_pts, points, num_faces, face_list, color);
}
static void GfxDebug::draw_shell ( int  num_pts,
const GPoint *  points,
int  num_faces,
const int *  face_list,
const int *  colors 
) [static]
void GfxDebug::draw_surface ( Surface *  surf,
int  color 
) [static]

Definition at line 606 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_surface(surf, color);
}
void GfxDebug::draw_tet ( CubitTet *  entity,
int  color 
) [static]

Definition at line 374 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_tet(entity, color);
}
void GfxDebug::draw_tets ( DLIList< CubitTet * > *  entities,
int  color 
) [static]

Definition at line 325 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_tets(entities, color);
}
void GfxDebug::draw_tri ( CubitTri *  entity,
int  color 
) [static]

Definition at line 369 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_tri(entity, color);
}
void GfxDebug::draw_tri ( const GPoint *  points,
int  color 
) [static]

Definition at line 543 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_tri(points, color);
}
void GfxDebug::draw_tris ( DLIList< CubitTri * > *  entities,
int  color 
) [static]

Definition at line 320 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_tris(entities, color);
}
void GfxDebug::draw_vector ( const GPoint *  tail,
const GPoint *  head,
int  color 
) [static]

Definition at line 555 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_vector(CubitVector(tail->x, tail->y, tail->z), CubitVector(head->x, head->y, head->z), color);
}
void GfxDebug::draw_vector ( const CubitVector &  tail,
const CubitVector &  head,
int  color 
) [static]

Definition at line 549 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_vector(tail, head, color);
}
void GfxDebug::draw_wedge ( CubitWedge *  entity,
int  color 
) [static]

Definition at line 390 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_wedge(entity, color);
}
void GfxDebug::draw_wedges ( DLIList< CubitWedge * > *  entities,
int  color 
) [static]

Definition at line 342 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_draw_wedges(entities, color);
}
void GfxDebug::drawing_mode ( int  mode) [static]

Definition at line 62 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_drawing_mode(mode);
}
void GfxDebug::flush ( ) [static]

Definition at line 101 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_flush();
}
void GfxDebug::highlight_edge ( CubitEdge *  entity) [static]

Definition at line 402 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_edge(entity);
}
void GfxDebug::highlight_hex ( CubitHex *  entity) [static]

Definition at line 426 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_hex(entity);
}
void GfxDebug::highlight_mref_body ( MBody *  entity) [static]

Definition at line 284 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_mref_body(entity);
}
void GfxDebug::highlight_mref_edge ( MRefEdge *  entity) [static]

Definition at line 266 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_mref_edge(entity);
}
void GfxDebug::highlight_mref_face ( MRefFace *  entity) [static]

Definition at line 272 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_mref_face(entity);
}
void GfxDebug::highlight_mref_vertex ( MRefVertex *  entity) [static]

Definition at line 260 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_mref_vertex(entity);
}
void GfxDebug::highlight_mref_volume ( MRefVolume *  entity) [static]

Definition at line 278 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_mref_volume(entity);
}
void GfxDebug::highlight_node ( CubitNode *  entity) [static]

Definition at line 396 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_node(entity);
}
void GfxDebug::highlight_points ( int  num_points,
const double *  xyzs 
) [static]

Definition at line 587 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_points(num_points, xyzs);
}
void GfxDebug::highlight_polygons ( int  num_points,
const double *  xyzs,
int  num_face_points,
const int *  face_list 
) [static]

Definition at line 599 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_polygons(num_points, xyzs, num_face_points, face_list);
}
void GfxDebug::highlight_polylines ( int  num_points,
const double *  xyzs,
int  num_line_points,
const int *  line_list 
) [static]

Definition at line 593 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_polylines(num_points, xyzs, num_line_points, line_list);
}
void GfxDebug::highlight_pyramid ( CubitPyramid *  entity) [static]

Definition at line 432 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_pyramid(entity);
}
void GfxDebug::highlight_quad ( CubitFace *  entity) [static]

Definition at line 408 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_quad(entity);
}
void GfxDebug::highlight_ref_body ( Body *  entity) [static]

Definition at line 246 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_ref_body(entity);
}
void GfxDebug::highlight_ref_edge ( RefEdge *  entity) [static]

Definition at line 228 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_ref_edge(entity);
}
void GfxDebug::highlight_ref_face ( RefFace *  entity) [static]

Definition at line 234 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_ref_face(entity);
}
void GfxDebug::highlight_ref_vertex ( RefVertex *  entity) [static]

Definition at line 222 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_ref_vertex(entity);
}
void GfxDebug::highlight_ref_volume ( RefVolume *  entity) [static]

Definition at line 240 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_ref_volume(entity);
}
void GfxDebug::highlight_tet ( CubitTet *  entity) [static]

Definition at line 420 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_tet(entity);
}
void GfxDebug::highlight_tri ( CubitTri *  entity) [static]

Definition at line 414 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_tri(entity);
}
void GfxDebug::highlight_wedge ( CubitWedge *  entity) [static]

Definition at line 438 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_highlight_wedge(entity);
}
bool GfxDebug::is_initialized ( ) [static]

Definition at line 27 of file GfxDebug.cpp.

{
  if (mInstance == 0)
    return false;
  return true;
}
void GfxDebug::mouse_xforms ( ) [static]

Definition at line 108 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_mouse_xforms();
}
virtual void GfxDebug::p_clear ( ) [protected, pure virtual]
virtual void GfxDebug::p_clear_highlight ( ) [protected, pure virtual]
virtual int GfxDebug::p_create_window ( ) [protected, pure virtual]
virtual void GfxDebug::p_delete_window ( int  ) [protected, pure virtual]
virtual void GfxDebug::p_display_all ( bool  ,
bool   
) [protected, pure virtual]
virtual void GfxDebug::p_display_to_world_length ( double  pixels,
double &  length 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_box ( CubitBox &  box,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_edge ( CubitEdge *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_edges ( DLIList< CubitEdge * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_facet ( CubitFacet *  ,
int  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_facet_edge ( CubitFacetEdge *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_geonode ( GeoNode *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_geotet ( GeoTet *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_hex ( CubitHex *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_hexes ( DLIList< CubitHex * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_label ( const char *  ,
float  ,
float  ,
float  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_label ( int  ,
float  ,
float  ,
float  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_line ( float  ,
float  ,
float  ,
float  ,
float  ,
float  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_line ( const CubitVector &  x,
const CubitVector &  y,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mesh_entity ( MeshEntity *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_body ( MBody *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_edge ( MRefEdge *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_entity ( MRefEntity *  entity,
int  color,
bool  geom,
bool  mesh,
CubitTransformMatrix *  mat 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_entity_mesh ( MRefEntity *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_face ( MRefFace *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_vertex ( MRefVertex *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_volume ( MRefVolume *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_mref_volume_faces ( MRefVolume *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_node ( CubitNode *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_nodes ( DLIList< CubitNode * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_point ( float  ,
float  ,
float  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_point ( const CubitVector &  vector,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_polygon ( const GPoint *  points,
int  num_points,
int  color,
int  border_color,
bool  filled 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_polyline ( const GPoint *  ,
int  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_pyramid ( CubitPyramid *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_quad ( CubitFace *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_quad ( const GPoint *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_quads ( DLIList< CubitFace * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_body ( Body *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_edge ( RefEdge *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_entity ( RefEntity *  entity,
int  color,
CubitTransformMatrix *  mat 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_face ( RefFace *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_face_edges ( RefFace *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_vertex ( RefVertex *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_ref_volume ( RefVolume *  entity,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_shell ( int  ,
const GPoint *  ,
int  ,
const int *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_shell ( int  ,
const GPoint *  ,
int  ,
const int *  ,
const int *   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_surface ( Surface *  surf,
int  color 
) [protected, pure virtual]
virtual void GfxDebug::p_draw_tet ( CubitTet *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_tets ( DLIList< CubitTet * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_tri ( CubitTri *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_tri ( const GPoint *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_tris ( DLIList< CubitTri * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_vector ( const CubitVector &  ,
const CubitVector &  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_wedge ( CubitWedge *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_draw_wedges ( DLIList< CubitWedge * > *  ,
int   
) [protected, pure virtual]
virtual void GfxDebug::p_drawing_mode ( int  ) [protected, pure virtual]
virtual void GfxDebug::p_flush ( ) [protected, pure virtual]
virtual void GfxDebug::p_highlight_edge ( CubitEdge *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_hex ( CubitHex *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_mref_body ( MBody *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_mref_edge ( MRefEdge *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_mref_face ( MRefFace *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_mref_vertex ( MRefVertex *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_mref_volume ( MRefVolume *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_node ( CubitNode *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_points ( int  num_points,
const double *  xyzs 
) [protected, pure virtual]
virtual void GfxDebug::p_highlight_polygons ( int  num_points,
const double *  xyzs,
int  num_face_points,
const int *  face_list 
) [protected, pure virtual]
virtual void GfxDebug::p_highlight_polylines ( int  num_points,
const double *  xyzs,
int  num_line_points,
const int *  line_list 
) [protected, pure virtual]
virtual void GfxDebug::p_highlight_pyramid ( CubitPyramid *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_quad ( CubitFace *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_ref_body ( Body *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_ref_edge ( RefEdge *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_ref_face ( RefFace *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_ref_vertex ( RefVertex *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_ref_volume ( RefVolume *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_tet ( CubitTet *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_tri ( CubitTri *  entity) [protected, pure virtual]
virtual void GfxDebug::p_highlight_wedge ( CubitWedge *  entity) [protected, pure virtual]
virtual void GfxDebug::p_mouse_xforms ( ) [protected, pure virtual]
virtual void GfxDebug::p_set_2D_mode ( int  ) [protected, pure virtual]
virtual void GfxDebug::p_zoom ( CubitBox &  box) [protected, pure virtual]
void GfxDebug::set_2D_mode ( int  window_id) [static]

Definition at line 94 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_set_2D_mode(window_id);
}
void GfxDebug::zoom ( CubitBox &  box) [static]

Definition at line 581 of file GfxDebug.cpp.

{
  if(!mInstance) return;
  mInstance->p_zoom(box);
}

Member Data Documentation

GfxDebug * GfxDebug::mInstance = 0 [static, protected]

Definition at line 59 of file GfxDebug.hpp.

The documentation for this class was generated from the following files:
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines