Branch data Line data Source code
1 : :
2 : :
3 : : #include "GfxPreview.hpp"
4 : : #include "GMem.hpp"
5 : : #include "CubitVector.hpp"
6 : : #include "Curve.hpp"
7 : : #include "Surface.hpp"
8 : : #include "GeometryQueryEngine.hpp"
9 : : #include "Point.hpp"
10 : : #include <assert.h>
11 : : #include "DrawingToolDefines.h"
12 : :
13 : : GfxPreview* GfxPreview::mInstance = 0;
14 : :
15 : 0 : GfxPreview::GfxPreview()
16 : : {
17 [ # # ]: 0 : if(mInstance)
18 : : {
19 : 0 : assert(0);
20 : : // if you want a new instance in place of a previous one,
21 : : // delete the previous one first
22 : : }
23 : 0 : mInstance = this;
24 : 0 : }
25 : :
26 : 0 : GfxPreview::~GfxPreview()
27 : : {
28 : 0 : mInstance = 0;
29 [ # # ]: 0 : }
30 : :
31 : :
32 : : // This clears preview data ONLY
33 : 22 : void GfxPreview::clear()
34 : : {
35 [ + - ]: 22 : if(!mInstance) return;
36 : 0 : mInstance->p_clear();
37 : : }
38 : :
39 : : // causes the current window to be redrawn
40 : 0 : void GfxPreview::flush()
41 : : {
42 [ # # ]: 0 : if(!mInstance) return;
43 : 0 : mInstance->p_flush();
44 : : }
45 : :
46 : : // Geometry Drawing Functions
47 : :
48 : 0 : void GfxPreview::draw_ref_entity(RefEntity* entity, int color, CubitTransformMatrix* mat)
49 : : {
50 [ # # ]: 0 : if(!mInstance) return;
51 : 0 : mInstance->p_draw_ref_entity(entity, color, mat);
52 : : }
53 : :
54 : 0 : void GfxPreview::draw_ref_vertex(RefVertex* entity, int color)
55 : : {
56 [ # # ]: 0 : if(!mInstance) return;
57 : 0 : mInstance->p_draw_ref_vertex(entity, color);
58 : : }
59 : :
60 : 0 : void GfxPreview::draw_ref_edge(RefEdge* entity, int color)
61 : : {
62 [ # # ]: 0 : if(!mInstance) return;
63 : 0 : mInstance->p_draw_ref_edge(entity, color);
64 : : }
65 : :
66 : 0 : void GfxPreview::draw_ref_face(RefFace* entity, int color)
67 : : {
68 [ # # ]: 0 : if(!mInstance) return;
69 : 0 : mInstance->p_draw_ref_face(entity, color);
70 : : }
71 : :
72 : 0 : void GfxPreview::draw_ref_face_edges(RefFace* entity, int color)
73 : : {
74 [ # # ]: 0 : if(!mInstance) return;
75 : 0 : mInstance->p_draw_ref_face_edges(entity, color);
76 : : }
77 : :
78 : 0 : void GfxPreview::draw_ref_volume(RefVolume* entity, int color, int mode)
79 : : {
80 [ # # ]: 0 : if(!mInstance) return;
81 : 0 : mInstance->p_draw_ref_volume(entity, color, mode);
82 : : }
83 : :
84 : 0 : void GfxPreview::draw_ref_volume_edges(RefVolume* entity, int color)
85 : : {
86 [ # # ]: 0 : if(!mInstance) return;
87 : 0 : mInstance->p_draw_ref_volume_edges(entity, color);
88 : : }
89 : :
90 : 0 : void GfxPreview::draw_ref_body(Body* entity, int color, int mode)
91 : : {
92 [ # # ]: 0 : if(!mInstance) return;
93 : 0 : mInstance->p_draw_ref_body(entity, color, mode);
94 : : }
95 : :
96 : : // Generic Primitive Drawing Functions
97 : :
98 : 0 : void GfxPreview::draw_box(CubitBox& box, int color)
99 : : {
100 [ # # ]: 0 : if(!mInstance) return;
101 : 0 : mInstance->p_draw_box(box, color);
102 : : }
103 : :
104 : : // draw point x,y,z of color
105 : 0 : void GfxPreview::draw_point(float x, float y, float z, int color)
106 : : {
107 [ # # ]: 0 : if(!mInstance) return;
108 : 0 : mInstance->p_draw_point(x, y, z, color);
109 : : }
110 : :
111 : 0 : void GfxPreview::draw_point(const CubitVector& vector, int color)
112 : : {
113 [ # # ]: 0 : if(!mInstance) return;
114 : 0 : mInstance->p_draw_point(vector, color);
115 : : }
116 : :
117 : 0 : void GfxPreview::draw_point(CubitVector* vector, int color)
118 : : {
119 [ # # ]: 0 : if(!mInstance) return;
120 : 0 : mInstance->p_draw_point(*vector, color);
121 : : }
122 : :
123 : : // draw line of points {x,y,z}, {x,y,z} of color
124 : 0 : void GfxPreview::draw_line(float x1, float y1, float z1, float x2, float y2, float z2, int color)
125 : : {
126 [ # # ]: 0 : if(!mInstance) return;
127 : 0 : mInstance->p_draw_line(x1, y1, z1, x2, y2, z2, color);
128 : : }
129 : :
130 : 0 : void GfxPreview::draw_line(const CubitVector& x, const CubitVector& y, int color)
131 : : {
132 [ # # ]: 0 : if(!mInstance) return;
133 : 0 : mInstance->p_draw_line(x, y, color);
134 : : }
135 : :
136 : : // draw a polyline with a number of points of a color
137 : 0 : void GfxPreview::draw_polyline(const GPoint* points, int num_points, int color)
138 : : {
139 [ # # ]: 0 : if(!mInstance) return;
140 : 0 : mInstance->p_draw_polyline(points, num_points, color);
141 : : }
142 : :
143 : : // draw polygons given the coordinates and the connectivity. Note that the
144 : : // connectivity (face_list) is given as the number of points in the polygon
145 : : // followed by the point ids for that polygon. So, the num_face_points is
146 : : // the total number of data points in the face_list such that
147 : : // num_face_points = number of points + number of polygons
148 : 0 : void GfxPreview::draw_polygons(int num_points, const double* xyzs, int num_face_points,
149 : : const int* face_list, int color, int mode )
150 : : {
151 [ # # ]: 0 : if (!mInstance)
152 : 0 : return;
153 : 0 : mInstance->p_draw_polygons( num_points, xyzs, num_face_points, face_list, color, mode);
154 : : }
155 : :
156 : : // draw a polyline with a number of points of a color
157 : 0 : void GfxPreview::draw_polygon(const GPoint* points, int num_points, int color, int border_color, bool filled)
158 : : {
159 [ # # ]: 0 : if(!mInstance) return;
160 : 0 : mInstance->p_draw_polygon(points, num_points, color, border_color, filled);
161 : : }
162 : :
163 : : // draw a quad of a color
164 : 0 : void GfxPreview::draw_quad(const GPoint* points, int color)
165 : : {
166 [ # # ]: 0 : if(!mInstance) return;
167 : 0 : mInstance->p_draw_quad(points, color);
168 : : }
169 : :
170 : : // draw a tri of a color
171 : 0 : void GfxPreview::draw_tri(const GPoint* points, int color)
172 : : {
173 [ # # ]: 0 : if(!mInstance) return;
174 : 0 : mInstance->p_draw_tri(points, color);
175 : : }
176 : :
177 : 0 : void GfxPreview::draw_vector(const CubitVector& tail, const CubitVector& head, int color)
178 : : {
179 [ # # ]: 0 : if(!mInstance) return;
180 : 0 : mInstance->p_draw_vector(tail, head, color);
181 : : }
182 : :
183 : 0 : void GfxPreview::draw_vector(const GPoint* tail, const GPoint* head, int color)
184 : : {
185 [ # # ]: 0 : if(!mInstance) return;
186 [ # # ][ # # ]: 0 : mInstance->p_draw_vector(CubitVector(tail->x, tail->y, tail->z), CubitVector(head->x, head->y, head->z), color);
187 : : }
188 : :
189 : : // draw a label at position x,y,z of color
190 : 0 : void GfxPreview::draw_label(const char* label, float x, float y, float z, int color)
191 : : {
192 [ # # ]: 0 : if(!mInstance) return;
193 : 0 : mInstance->p_draw_label(label, x, y, z, color);
194 : : }
195 : 0 : void GfxPreview::draw_label(int label, float x, float y, float z, int color)
196 : : {
197 [ # # ]: 0 : if(!mInstance) return;
198 : 0 : mInstance->p_draw_label(label, x, y, z, color);
199 : : }
200 : :
201 : 0 : void GfxPreview:: draw_cylinder(const CubitVector& axis, const CubitVector& origin,
202 : : CubitBox& bounding_box, float radius, int color)
203 : : {
204 [ # # ]: 0 : if(!mInstance) return;
205 : 0 : mInstance->p_draw_cylinder(axis, origin, bounding_box, radius, color);
206 : : }
207 : :
208 : 0 : void GfxPreview:: draw_frustum( const CubitVector axis , const CubitVector origin1, const CubitVector origin2,double dRad1 , double dRad2,
209 : : CubitBox& bounding_box ,int color)
210 : : {
211 [ # # ]: 0 : if(!mInstance) return;
212 [ # # ][ # # ]: 0 : mInstance->p_draw_frustum( axis , origin1, origin2, dRad1 , dRad2 , bounding_box, color);
[ # # ][ # # ]
213 : : }
214 : :
215 : 0 : void GfxPreview::draw_point(TBPoint *pt, int color)
216 : : {
217 [ # # ]: 0 : CubitVector v = pt->coordinates();
218 [ # # ]: 0 : draw_point(v, color);
219 [ # # ]: 0 : flush();
220 : 0 : }
221 : :
222 : 0 : void GfxPreview::draw_curve(Curve *curve, int color)
223 : : {
224 : 0 : int num_divs = 20;
225 : : double lo, hi;
226 [ # # ]: 0 : curve->get_param_range(lo, hi);
227 : 0 : double dv = (hi-lo)/(double)num_divs;
228 : : int i;
229 : 0 : double param = lo;
230 [ # # ]: 0 : for(i=0; i<num_divs; i++)
231 : : {
232 [ # # ][ # # ]: 0 : CubitVector p1, p2;
233 [ # # ]: 0 : curve->position_from_u(param, p1);
234 : 0 : param += dv;
235 [ # # ]: 0 : curve->position_from_u(param, p2);
236 [ # # ][ # # ]: 0 : draw_line(p1.x(), p1.y(), p1.z(), p2.x(), p2.y(), p2.z(), color);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
237 : : }
238 [ # # ]: 0 : flush();
239 [ # # ]: 0 : DLIList<TBPoint*> pts;
240 [ # # ]: 0 : curve->points(pts);
241 [ # # ][ # # ]: 0 : for(i=pts.size(); i>0; i--)
242 : : {
243 [ # # ]: 0 : TBPoint *cur_pt = pts.get_and_step();
244 [ # # ]: 0 : draw_point(cur_pt, color);
245 [ # # ]: 0 : }
246 : 0 : }
247 : :
248 : 0 : void GfxPreview::draw_surface(Surface *surf, int color)
249 : : {
250 : 0 : int num_divs = 20;
251 : : double ulo, uhi, vlo, vhi;
252 [ # # ]: 0 : surf->get_param_range_U(ulo, uhi);
253 [ # # ]: 0 : surf->get_param_range_V(vlo, vhi);
254 : 0 : double du = (uhi-ulo)/(double)num_divs;
255 : 0 : double dv = (vhi-vlo)/(double)num_divs;
256 : : int i, j;
257 : : double uparam, vparam;
258 : 0 : uparam = ulo;
259 [ # # ]: 0 : for(i=0; i<num_divs; i++)
260 : : {
261 : 0 : vparam = vlo;
262 [ # # ]: 0 : for(j=0; j<num_divs; j++)
263 : : {
264 [ # # ][ # # ]: 0 : CubitVector p1, p2;
265 [ # # ][ # # ]: 0 : p1 = surf->position_from_u_v(uparam, vparam);
266 : 0 : vparam += dv;
267 [ # # ][ # # ]: 0 : p2 = surf->position_from_u_v(uparam, vparam);
268 [ # # ][ # # ]: 0 : draw_line(p1.x(), p1.y(), p1.z(), p2.x(), p2.y(), p2.z(), color);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
269 : : }
270 : 0 : uparam += du;
271 : : }
272 : 0 : vparam = vlo;
273 [ # # ]: 0 : for(i=0; i<num_divs; i++)
274 : : {
275 : 0 : uparam = ulo;
276 [ # # ]: 0 : for(j=0; j<num_divs; j++)
277 : : {
278 [ # # ][ # # ]: 0 : CubitVector p1, p2;
279 [ # # ][ # # ]: 0 : p1 = surf->position_from_u_v(uparam, vparam);
280 : 0 : uparam += du;
281 [ # # ][ # # ]: 0 : p2 = surf->position_from_u_v(uparam, vparam);
282 [ # # ][ # # ]: 0 : draw_line(p1.x(), p1.y(), p1.z(), p2.x(), p2.y(), p2.z(), color);
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
283 : : }
284 : 0 : vparam += dv;
285 : : }
286 [ # # ]: 0 : flush();
287 : 0 : }
288 : :
289 : 0 : void GfxPreview::draw_surface_facets_shaded(Surface *surf, int color)
290 : : {
291 [ # # ]: 0 : GMem g_mem;
292 : :
293 [ # # ][ # # ]: 0 : surf->get_geometry_query_engine()->get_graphics(surf, &g_mem);
294 : :
295 [ # # ]: 0 : const float* xyzs = reinterpret_cast<const float*>(g_mem.point_list());
296 [ # # ][ # # ]: 0 : std::vector<double> dcoords(xyzs, xyzs+g_mem.pointListCount*3);
297 [ # # ]: 0 : GfxPreview::draw_polygons(g_mem.pointListCount, &dcoords[0],
298 [ # # ]: 0 : g_mem.fListCount, g_mem.facet_list(),
299 [ # # ]: 0 : color, CUBIT_SMOOTH_SHADING);
300 [ # # ][ # # ]: 0 : flush();
301 [ + - ][ + - ]: 6540 : }
302 : :
|
