- Fixed brushexport2 output float-format (Shaderman)
[xonotic/netradiant.git] / contrib / gtkgensurf / view.cpp
1 /*
2 GenSurf plugin for GtkRadiant
3 Copyright (C) 2001 David Hyde, Loki software and qeradiant.com
4
5 This library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 This library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18 */
19
20 #include <math.h>
21 #include <stdio.h>
22 #include <stdlib.h>
23 #include "gensurf.h"
24
25 #undef ISOMETRIC
26
27 extern double backface;
28 extern double dh, dv;
29 extern double xmin,xmax,ymin,ymax,zmin,zmax;
30
31 double    SF, SFG;         // Graphics scale factors
32 double    XLo, XHi, YLo, YHi, ZLo, ZHi;
33 double    yaw,roll;
34 double    elevation,azimuth;
35 int       cxChar = 10, cyChar = 16;
36 int       X0, Y0;
37 int       X0G, Y0G;
38
39 static Rect rcCoord;   // where X= Y= is drawn
40 static Rect rcGrid;    // rectangle within rcLower that forms the border of the grid, plus
41                        //   a 3 pixel slop.
42 static Rect rcLower;   // lower half of window, where plan view is drawn
43 static Rect rcUpper;   // upper half or entire window, where isometric projection is drawn
44
45 void vertex_selected ();
46 void texfont_init ();
47 void texfont_write (const char *text, int l, int t);
48
49 #define PEN_GRID { \
50   g_GLTable.m_pfn_qglLineWidth (1); \
51   g_GLTable.m_pfn_qglColor3f (0, 1, 0); \
52   g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE); }
53
54 #define PEN_RED { \
55   g_GLTable.m_pfn_qglLineWidth (2); \
56   g_GLTable.m_pfn_qglColor3f (1, 0, 0); \
57   g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE); }
58
59 #define PEN_DASH { \
60   g_GLTable.m_pfn_qglLineWidth (1); \
61   g_GLTable.m_pfn_qglColor3f (0, 1, 0); \
62   g_GLTable.m_pfn_qglLineStipple (1, 0xF0F0); \
63   g_GLTable.m_pfn_qglEnable (GL_LINE_STIPPLE); }
64
65 #define DRAW_QUAD(rc,r,g,b) { \
66   g_GLTable.m_pfn_qglBegin (GL_QUADS); \
67   g_GLTable.m_pfn_qglColor3f (0,1,0); \
68   g_GLTable.m_pfn_qglVertex2i (rc.left-1, rc.bottom); \
69   g_GLTable.m_pfn_qglVertex2i (rc.right, rc.bottom); \
70   g_GLTable.m_pfn_qglVertex2i (rc.right, rc.top+1); \
71   g_GLTable.m_pfn_qglVertex2i (rc.left-1, rc.top+1); \
72   g_GLTable.m_pfn_qglColor3f (r,g,b); \
73   g_GLTable.m_pfn_qglVertex2i (rc.left, rc.bottom+1); \
74   g_GLTable.m_pfn_qglVertex2i (rc.right-1, rc.bottom+1); \
75   g_GLTable.m_pfn_qglVertex2i (rc.right-1, rc.top); \
76   g_GLTable.m_pfn_qglVertex2i (rc.left, rc.top); \
77   g_GLTable.m_pfn_qglEnd (); }
78
79
80 #ifndef ISOMETRIC
81 double    D=65536.;
82 double    ct[3],st[3];
83 double    Hhi, Hlo, Vhi, Vlo;
84 #endif
85
86 #define SUBDIVS 6
87
88
89 void ShowPreview ()
90 {
91   if (Preview)
92   {
93     if (g_pWndPreview == NULL)
94       CreateViewWindow ();
95     gtk_widget_show (g_pWndPreview);
96
97     UpdatePreview (true);
98   }
99   else
100     gtk_widget_hide (g_pWndPreview);
101 }
102
103 static void draw_preview ()
104 {
105   int width = g_pPreviewWidget->allocation.width, height = g_pPreviewWidget->allocation.height;
106
107   g_GLTable.m_pfn_qglClearColor (0, 0, 0, 1);
108   g_GLTable.m_pfn_qglViewport (0, 0, width, height);
109   g_GLTable.m_pfn_qglMatrixMode (GL_PROJECTION);
110   g_GLTable.m_pfn_qglLoadIdentity ();
111   g_GLTable.m_pfn_qglOrtho (0, width, 0, height, -1, 1);
112   g_GLTable.m_pfn_qglClear (GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
113         
114         // ^Fishman - Antializing for the preview window.
115         if (Antialiasing)
116         {
117                 g_GLTable.m_pfn_qglEnable(GL_BLEND);
118                 g_GLTable.m_pfn_qglBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
119                 g_GLTable.m_pfn_qglEnable(GL_LINE_SMOOTH);
120         }
121         else
122         {
123                 g_GLTable.m_pfn_qglDisable(GL_BLEND);
124                 g_GLTable.m_pfn_qglDisable(GL_LINE_SMOOTH);
125         }
126
127   texfont_init ();
128
129   if (!ValidSurface ())
130     return;
131
132   rcUpper.left = 0;
133   rcUpper.right = width;
134   rcUpper.bottom = 0;
135   rcUpper.top = height;
136   rcLower.left = 0;
137   rcLower.right = width;
138   rcLower.bottom = 0;
139   rcLower.top = height;
140
141   if (VertexMode)
142   {
143     rcUpper.bottom = rcUpper.top/2;
144     DrawPreview (rcUpper);
145     g_GLTable.m_pfn_qglBegin (GL_LINES);
146     g_GLTable.m_pfn_qglVertex2i (rcUpper.left, rcUpper.bottom);
147     g_GLTable.m_pfn_qglVertex2i (rcUpper.right, rcUpper.bottom);
148     g_GLTable.m_pfn_qglEnd ();
149     rcLower.top = rcUpper.bottom-1;
150     DrawGrid (rcLower);
151     rcCoord.left = rcLower.left;
152     rcCoord.right = rcLower.right;
153     rcCoord.bottom = rcLower.bottom;
154     rcCoord.top = rcLower.top;
155     rcCoord.top = rcCoord.bottom+cyChar;
156     rcCoord.right = rcCoord.left + 15*cxChar;
157     rcGrid.left   = X0G - 3;
158     rcGrid.bottom = Y0G - 3;
159     rcGrid.right  = X0G + (int)(SFG*(Hur-Hll)) + 3;
160     rcGrid.top    = Y0G + (int)(SFG*(Vur-Vll)) + 3;
161   }
162   else
163     DrawPreview (rcUpper);
164 }
165
166 static gint expose (GtkWidget *widget, GdkEventExpose *event, gpointer data)
167 {
168   if (event->count > 0)
169     return TRUE;
170
171   if (!g_UIGtkTable.m_pfn_glwidget_make_current (g_pPreviewWidget))
172   {
173     g_FuncTable.m_pfnSysPrintf ("GtkGenSurf: glMakeCurrent failed\n");
174     return TRUE;
175   }
176
177   draw_preview ();
178
179   g_UIGtkTable.m_pfn_glwidget_swap_buffers (g_pPreviewWidget);
180   g_GLTable.m_pfn_QE_CheckOpenGLForErrors ();
181
182   return TRUE;
183 }
184
185 static void button_press (GtkWidget *widget, GdkEventButton *event, gpointer data)
186 {
187   Point pt = { (long)event->x, widget->allocation.height - (long)event->y };
188   bool        Selected;
189   double      x,y;
190   int         i, j, k, ks;
191   int         i0, i1, j0, j1;
192
193   if ((!VertexMode) || (event->button != 1))
194     return;
195
196   if (!PtInRect (&rcGrid,pt))
197   {
198     gdk_beep ();
199     return;
200   }
201
202   x = Hll + (pt.x-X0G)/SFG;
203   y = Vur - (pt.y-Y0G)/SFG;
204   i = (int)(floor( (x-Hll)/dh - 0.5) + 1);
205   j = (int)(floor( (y-Vll)/dv - 0.5) + 1);
206   if (i < 0 || i > NH || j < 0 || j > NV)
207   {
208     gdk_beep ();
209     return;
210   }
211
212   if(!CanEdit(i,j))
213   {
214     gdk_beep ();
215     return;
216   }
217
218   // Control key pressed - add this point, or remove it if already selected
219   if ((event->state & GDK_CONTROL_MASK) != 0)
220   {
221     Selected = FALSE;
222     if (NumVerticesSelected)
223     {
224       for (k=0; k<NumVerticesSelected && !Selected; k++)
225       {
226         if(Vertex[k].i == i && Vertex[k].j == j)
227         {
228           Selected = TRUE;
229           ks = k;
230         }
231       }
232     }
233
234     // Already selected - unselect it.
235     if (Selected)
236     {
237       if (ks < NumVerticesSelected)
238       {
239         for (k=ks;k<NumVerticesSelected-1;k++)
240         {
241           Vertex[k].i = Vertex[k+1].i;
242           Vertex[k].j = Vertex[k+1].j;
243         }
244         NumVerticesSelected--;
245       }
246     }
247     else
248     {
249       Vertex[NumVerticesSelected].i = i;
250       Vertex[NumVerticesSelected].j = j;
251       NumVerticesSelected++;
252     }
253   }
254   else if ((event->state & GDK_SHIFT_MASK) != 0)
255   {
256     if (NumVerticesSelected)
257     {
258       NumVerticesSelected = 1;
259       i0 = min(Vertex[0].i, i);
260       i1 = max(Vertex[0].i, i);
261       j0 = min(Vertex[0].j, j);
262       j1 = max(Vertex[0].j, j);
263       for(i=i0; i<=i1; i++)
264       {
265         for(j=j0; j<=j1; j++)
266         {
267           if(i==0  && j==0 ) continue;
268           if(i==NH && j==0 ) continue;
269           if(i==0  && j==NV) continue;
270           if(i==NH && j==NV) continue;
271           if(i != Vertex[0].i || j != Vertex[0].j)
272           {
273             Vertex[NumVerticesSelected].i = i;
274             Vertex[NumVerticesSelected].j = j;
275             NumVerticesSelected++;
276           }
277         }
278       }
279     }
280     else
281     {
282       Vertex[0].i = i;
283       Vertex[0].j = j;
284       NumVerticesSelected = 1;
285     }
286   }
287   else
288   {
289     Vertex[0].i = i;
290     Vertex[0].j = j;
291     NumVerticesSelected = 1;
292   }
293
294   vertex_selected ();
295 }
296
297 static void motion (GtkWidget *widget, GdkEventMotion *event, gpointer data)
298 {
299   Point pt = { (long)event->x, widget->allocation.height - (long)event->y };
300
301   if (!VertexMode)
302     return;
303
304   if (!g_UIGtkTable.m_pfn_glwidget_make_current (g_pPreviewWidget))
305   {
306     g_FuncTable.m_pfnSysPrintf ("GtkGenSurf: glMakeCurrent failed\n");
307     return;
308   }
309
310   g_GLTable.m_pfn_qglEnable (GL_SCISSOR_TEST);
311   g_GLTable.m_pfn_qglScissor (rcCoord.left, rcCoord.bottom, rcCoord.right-rcCoord.left,
312                               rcCoord.top-rcCoord.bottom);
313   g_GLTable.m_pfn_qglClear (GL_COLOR_BUFFER_BIT);
314
315   if (PtInRect(&rcGrid,pt))
316   {
317     GdkCursor *cursor = gdk_cursor_new (GDK_CROSS);
318     gdk_window_set_cursor (g_pWndPreview->window, cursor);
319     gdk_cursor_unref (cursor);
320
321     char Text[32];
322     int x, y;
323
324     x = (int)(Hll + (pt.x-X0G)/SFG);
325     y = (int)(Vur - (pt.y-Y0G)/SFG);
326     switch(Plane)
327     {
328     case PLANE_XZ0:
329     case PLANE_XZ1:
330       sprintf(Text," x=%d, z=%d   ",(int)(floor(x-0.5)+1.) ,(int)(floor(y-0.5)+1.) );
331       break;
332     case PLANE_YZ0:
333     case PLANE_YZ1:
334       sprintf(Text," y=%d, z=%d   ",(int)(floor(x-0.5)+1.) ,(int)(floor(y-0.5)+1.) );
335       break;
336     default:
337       sprintf(Text," x=%d, y=%d   ",(int)(floor(x-0.5)+1.) ,(int)(floor(y-0.5)+1.) );
338     }
339
340     texfont_write (Text, rcCoord.left, rcCoord.top);
341   }
342   else
343   {
344     gdk_window_set_cursor (g_pWndPreview->window, NULL);
345   }
346
347   g_UIGtkTable.m_pfn_glwidget_swap_buffers (g_pPreviewWidget);
348   g_GLTable.m_pfn_QE_CheckOpenGLForErrors ();
349   g_GLTable.m_pfn_qglDisable (GL_SCISSOR_TEST);
350 }
351
352 static gint preview_close (GtkWidget *widget, gpointer data)
353 {
354   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (g_object_get_data (G_OBJECT (g_pWnd), "main_preview")), FALSE);
355   return TRUE;
356 }
357
358 static void preview_focusout (GtkSpinButton *spin, GdkEventFocus *event, double *data)
359 {
360   *data = DegreesToRadians ((double)(gtk_spin_button_get_value_as_int (spin) % 360));
361   UpdatePreview (false);
362 }
363
364 static gint doublevariable_spinfocusout(GtkWidget* widget, GdkEventFocus* event, gpointer data)
365 {
366   preview_focusout(GTK_SPIN_BUTTON(widget), event, reinterpret_cast<double*>(data));
367   return FALSE;
368 }
369
370 static void preview_spin (GtkAdjustment *adj, double *data)
371 {
372   *data = DegreesToRadians (adj->value);
373   UpdatePreview (false);
374 }
375
376 void CreateViewWindow ()
377 {
378   GtkWidget *dlg, *vbox, *hbox, *label, *spin, *frame;
379   GtkObject *adj;
380
381 #ifndef ISOMETRIC
382   elevation = PI/6.;
383   azimuth   = PI/6.;
384 #endif
385
386   g_pWndPreview = dlg = gtk_window_new (GTK_WINDOW_TOPLEVEL);
387   gtk_window_set_title (GTK_WINDOW (dlg), "GtkGenSurf Preview");
388   gtk_signal_connect (GTK_OBJECT (dlg), "delete_event", GTK_SIGNAL_FUNC (preview_close), NULL);
389   gtk_signal_connect (GTK_OBJECT (dlg), "destroy", GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
390   gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (g_pWnd));
391   gtk_window_set_default_size (GTK_WINDOW (dlg), 300, 400);
392
393   vbox = gtk_vbox_new (FALSE, 5);
394   gtk_widget_show (vbox);
395   gtk_container_add (GTK_CONTAINER (dlg), vbox);
396
397 #ifndef ISOMETRIC
398   hbox = gtk_hbox_new (TRUE, 5);
399   gtk_widget_show (hbox);
400   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, TRUE, 0);
401   gtk_container_set_border_width (GTK_CONTAINER (hbox), 3);
402
403   label = gtk_label_new ("Elevation");
404   gtk_widget_show (label);
405   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
406   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, TRUE, 0);
407
408   adj = gtk_adjustment_new (30, -90, 90, 1, 10, 10);
409   gtk_signal_connect (adj, "value_changed", GTK_SIGNAL_FUNC (preview_spin), &elevation);
410   spin = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
411   gtk_widget_show (spin);
412   gtk_box_pack_start (GTK_BOX (hbox), spin, FALSE, TRUE, 0);
413   g_signal_connect (G_OBJECT (spin), "focus_out_event", G_CALLBACK (doublevariable_spinfocusout), &elevation);
414
415   adj = gtk_adjustment_new (30, 0, 359, 1, 10, 10);
416   gtk_signal_connect (adj, "value_changed", GTK_SIGNAL_FUNC (preview_spin), &azimuth);
417   spin = gtk_spin_button_new (GTK_ADJUSTMENT (adj), 1, 0);
418   gtk_widget_show (spin);
419   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (spin), TRUE);
420   gtk_box_pack_end (GTK_BOX (hbox), spin, FALSE, TRUE, 0);
421
422   label = gtk_label_new ("Azimuth");
423   gtk_widget_show (label);
424   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
425   gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, TRUE, 0);
426   g_signal_connect (G_OBJECT (spin), "focus_out_event", G_CALLBACK (doublevariable_spinfocusout), &azimuth);
427 #endif
428
429   frame = gtk_frame_new (NULL);
430   gtk_widget_show (frame);
431   gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
432   gtk_box_pack_start (GTK_BOX (vbox), frame, TRUE, TRUE, 0);
433
434   g_pPreviewWidget = g_UIGtkTable.m_pfn_glwidget_new (FALSE, NULL);
435
436   gtk_widget_set_events (g_pPreviewWidget, GDK_EXPOSURE_MASK|GDK_BUTTON_PRESS_MASK|GDK_POINTER_MOTION_MASK);
437   gtk_signal_connect (GTK_OBJECT (g_pPreviewWidget), "expose_event", GTK_SIGNAL_FUNC (expose), NULL);
438   gtk_signal_connect (GTK_OBJECT (g_pPreviewWidget), "motion_notify_event", GTK_SIGNAL_FUNC (motion), NULL);
439   gtk_signal_connect (GTK_OBJECT (g_pPreviewWidget), "button_press_event",
440                       GTK_SIGNAL_FUNC (button_press), NULL);
441
442   gtk_widget_show (g_pPreviewWidget);
443   gtk_container_add (GTK_CONTAINER (frame), g_pPreviewWidget);
444
445   if (Preview)
446     gtk_widget_show (g_pWndPreview);
447
448   UpdatePreview (true);
449 }
450
451 //=============================================================
452 /* DrawPreview */
453 void DrawPreview (Rect rc)
454 {
455 #define COSXA 0.8660254037844
456 #define SINXA 0.5
457 #define COSYA 0.8660254037844
458 #define SINYA 0.5
459
460   double     L;
461   double     x,y;
462   int        i, j;
463   Point      pt[8];
464   XYZ        v[8];
465   char axis[3][2] = {"X","Y","Z"};
466
467 #ifndef ISOMETRIC
468   evaluate();
469 #endif
470
471   XLo = xmin;
472   XHi = xmax;
473   YLo = ymin;
474   YHi = ymax;
475   ZLo = zmin;
476   ZHi = zmax;
477   switch (Plane)
478   {
479   case PLANE_XY1:
480     ZHi = backface;
481     break;
482   case PLANE_XZ0:
483     YLo = backface;
484     break;
485   case PLANE_XZ1:
486     YHi = backface;
487     break;
488   case PLANE_YZ0:
489     XLo = backface;
490     break;
491   case PLANE_YZ1:
492     XHi = backface;
493     break;
494   default:
495     ZLo = backface;
496   }
497
498
499
500   GetScaleFactor(rc);
501         //PEN_GRID
502         g_GLTable.m_pfn_qglLineWidth (1);
503         g_GLTable.m_pfn_qglColor3f (0, 1, 0);
504         g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
505
506     if (Decimate > 0 && (Game != QUAKE3 || UsePatches==0) )
507     {
508       XYZ  *vv;
509
510       vv   = (XYZ *) malloc(gNumNodes * sizeof(XYZ));
511       for(i=0; i<gNumNodes; i++)
512       {
513         for(j=0; j<3; j++)
514           vv[i].p[j] = (double)(gNode[i].p[j]);
515         project(&vv[i]);
516       }
517
518       for(i=0; i<gNumTris; i++)
519       {
520         for(j=0; j<3; j++)
521           Scale(rc,vv[gTri[i].v[j]],&pt[j]);
522
523         g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
524         g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
525         g_GLTable.m_pfn_qglVertex2i (pt[1].x, pt[1].y);
526         g_GLTable.m_pfn_qglVertex2i (pt[2].x, pt[2].y);
527         g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
528         g_GLTable.m_pfn_qglEnd ();
529       }
530       free(vv);
531     }
532     else if (Game==QUAKE3 && UsePatches!=0)
533     {
534       int               axis, ii, jj, k;
535       float     u, v;
536       XYZ               uv[3][3];
537       XYZ               Ctrl[3],out;
538
539       switch (Plane)
540       {
541       case PLANE_XY0:
542       case PLANE_XY1:
543         k = 2;
544         break;
545       case PLANE_XZ0:
546       case PLANE_XZ1:
547         k = 1;
548         break;
549       default:
550         k = 0;
551       }
552       for(i=0; i<NH; i+=2)
553       {
554         for(j=0; j<NV; j+=2)
555         {
556           VectorCopy(xyz[i  ][j  ].p,uv[0][0].p);
557           VectorCopy(xyz[i+1][j  ].p,uv[1][0].p);
558           VectorCopy(xyz[i+2][j  ].p,uv[2][0].p);
559           VectorCopy(xyz[i  ][j+1].p,uv[0][1].p);
560           VectorCopy(xyz[i+1][j+1].p,uv[1][1].p);
561           VectorCopy(xyz[i+2][j+1].p,uv[2][1].p);
562           VectorCopy(xyz[i  ][j+2].p,uv[0][2].p);
563           VectorCopy(xyz[i+1][j+2].p,uv[1][2].p);
564           VectorCopy(xyz[i+2][j+2].p,uv[2][2].p);
565           uv[1][0].p[k] = (4*xyz[i+1][j  ].p[k] - xyz[i  ][j  ].p[k] - xyz[i+2][j  ].p[k])/2;
566           uv[0][1].p[k] = (4*xyz[i  ][j+1].p[k] - xyz[i  ][j  ].p[k] - xyz[i  ][j+2].p[k])/2;
567           uv[2][1].p[k] = (4*xyz[i+2][j+1].p[k] - xyz[i+2][j  ].p[k] - xyz[i+2][j+2].p[k])/2;
568           uv[1][2].p[k] = (4*xyz[i+1][j+2].p[k] - xyz[i  ][j+2].p[k] - xyz[i+2][j+2].p[k])/2;
569           uv[1][1].p[k] = (16*xyz[i+1][j+1].p[k] -
570                            xyz[i  ][j  ].p[k] - 2*xyz[i+1][j  ].p[k] -  xyz[i+2][j  ].p[k] -
571                            2*xyz[i  ][j+1].p[k]                        -2*xyz[i+2][j+1].p[k] -
572                            xyz[i  ][j+2].p[k] - 2*xyz[i+1][j+2].p[k] -  xyz[i+2][j+2].p[k]   )/4;
573
574           for(ii=0; ii<=SUBDIVS; ii++)
575           {
576             if(ii==0 || ii==SUBDIVS/2 || ii==SUBDIVS)
577                                                 {
578                                                         g_GLTable.m_pfn_qglLineWidth (1);
579                                                         g_GLTable.m_pfn_qglColor3f (0, 1, 0);
580                                                         g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
581                                                         // PEN_GRID
582                                                 }
583             else
584                                                 {
585                                                         g_GLTable.m_pfn_qglLineWidth (1);
586                                                         g_GLTable.m_pfn_qglColor3f (0, 1, 0);
587                                                         g_GLTable.m_pfn_qglLineStipple (1, 0xF0F0);
588                                                         g_GLTable.m_pfn_qglEnable (GL_LINE_STIPPLE);
589               // PEN_DASH
590                                                 }
591
592             u = (float)(ii)/(float)(SUBDIVS);
593             for(jj=0; jj<3; jj++)
594             {
595               for(axis=0; axis<3; axis++)
596               {
597                 float   a, b, c;
598                 float   qA, qB, qC;
599                 a = (float)uv[0][jj].p[axis];
600                 b = (float)uv[1][jj].p[axis];
601                 c = (float)uv[2][jj].p[axis];
602                 qA = a - 2 * b + c;
603                 qB = 2 * b - 2 * a;
604                 qC = a;
605                 Ctrl[jj].p[axis] = qA * u * u + qB * u + qC;
606               }
607             }
608             VectorCopy(Ctrl[0].p,out.p);
609             project(&out);
610             Scale(rc,out,&pt[0]);
611             g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
612             g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
613             for(jj=1; jj<=SUBDIVS; jj++)
614             {
615               v = (float)(jj)/(float)(SUBDIVS);
616               for (axis = 0 ; axis < 3 ; axis++) 
617               {
618                 float   a, b, c;
619                 float   qA, qB, qC;
620                 a = (float)Ctrl[0].p[axis];
621                 b = (float)Ctrl[1].p[axis];
622                 c = (float)Ctrl[2].p[axis];
623                 qA = a - 2 * b + c;
624                 qB = 2 * b - 2 * a;
625                 qC = a;
626                 out.p[axis] = qA * v * v + qB * v + qC;
627               }
628               project(&out);
629               Scale(rc,out,&pt[0]);
630               g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
631             }
632             g_GLTable.m_pfn_qglEnd ();
633           }
634           for(jj=0; jj<=SUBDIVS; jj++)
635           {
636             if(jj==0 || jj==SUBDIVS/2 || jj==SUBDIVS)
637                                                 {
638                                                         g_GLTable.m_pfn_qglLineWidth (1);
639                                                         g_GLTable.m_pfn_qglColor3f (0, 1, 0);
640                                                         g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
641               // PEN_GRID
642                                                 }
643             else
644                                                 {
645                                                         g_GLTable.m_pfn_qglLineWidth (1);
646                                                         g_GLTable.m_pfn_qglColor3f (0, 1, 0);
647                                                         g_GLTable.m_pfn_qglLineStipple (1, 0xF0F0);
648                                                         g_GLTable.m_pfn_qglEnable (GL_LINE_STIPPLE);
649                                                         // PEN_DASH
650                                                 }
651
652             v = (float)(jj)/(float)(SUBDIVS);
653             for(ii=0; ii<3; ii++)
654             {
655               for(axis=0; axis<3; axis++)
656               {
657                 float   a, b, c;
658                 float   qA, qB, qC;
659                 a = (float)uv[ii][0].p[axis];
660                 b = (float)uv[ii][1].p[axis];
661                 c = (float)uv[ii][2].p[axis];
662                 qA = a - 2 * b + c;
663                 qB = 2 * b - 2 * a;
664                 qC = a;
665                 Ctrl[ii].p[axis] = qA * v * v + qB * v + qC;
666               }
667             }
668             VectorCopy(Ctrl[0].p,out.p);
669             project(&out);
670             Scale(rc,out,&pt[0]);
671             g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
672             g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
673             for(ii=1; ii<=SUBDIVS; ii++)
674             {
675               u = (float)(ii)/(float)(SUBDIVS);
676               for (axis = 0 ; axis < 3 ; axis++) 
677               {
678                 float   a, b, c;
679                 float   qA, qB, qC;
680                 a = (float)Ctrl[0].p[axis];
681                 b = (float)Ctrl[1].p[axis];
682                 c = (float)Ctrl[2].p[axis];
683                 qA = a - 2 * b + c;
684                 qB = 2 * b - 2 * a;
685                 qC = a;
686                 out.p[axis] = qA * u * u + qB * u + qC;
687               }
688               project(&out);
689               Scale(rc,out,&pt[0]);
690               g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
691             }
692             g_GLTable.m_pfn_qglEnd ();
693           }
694         }
695       }
696     }
697     else
698     {
699       for(i=0; i<=NH; i++)
700       {
701         Scale(rc,xyz[i][0],&pt[0]);
702         g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
703         g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
704         for(j=1; j<=NV; j++)
705         {
706           Scale(rc,xyz[i][j],&pt[0]);
707           g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
708         }
709         g_GLTable.m_pfn_qglEnd ();
710       }
711       for(j=0; j<=NV; j++)
712       {
713         Scale(rc,xyz[0][j],&pt[0]);
714         g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
715         g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
716         for(i=1; i<=NH; i++)
717         {
718           Scale(rc,xyz[i][j],&pt[0]);
719           g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
720         }
721         g_GLTable.m_pfn_qglEnd ();
722       }
723     }
724
725   if(Game!=QUAKE3 || UsePatches==0)
726   {
727     // Draw lines from corners to base, and lines around base
728     for(i=0; i<=NH; i+=NH)
729     {
730       for(j=0; j<=NV; j+=NV)
731       {
732         VectorCopy(xyz[i][j].p, v[0].p);
733         switch(Plane)
734         {
735         case PLANE_XZ0:
736         case PLANE_XZ1:
737           v[0].p[1] = backface;
738           break;
739         case PLANE_YZ0:
740         case PLANE_YZ1:
741           v[0].p[0] = backface;
742           break;
743         default:
744           v[0].p[2] = backface;
745         }
746         Scale(rc,xyz[i][j],&pt[0]);
747 #ifndef ISOMETRIC
748         project(&v[0]);
749 #endif
750         Scale(rc,v[0],&pt[1]);
751         g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
752         g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
753         g_GLTable.m_pfn_qglVertex2i (pt[1].x, pt[1].y);
754         g_GLTable.m_pfn_qglEnd ();
755       }
756     }
757     VectorCopy(xyz[ 0][ 0].p, v[0].p);
758     VectorCopy(xyz[NH][ 0].p, v[1].p);
759     VectorCopy(xyz[NH][NV].p, v[2].p);
760     VectorCopy(xyz[ 0][NV].p, v[3].p);
761     switch(Plane)
762     {
763     case PLANE_XZ0:
764     case PLANE_XZ1:
765       v[0].p[1] = backface;;
766       v[1].p[1] = v[0].p[1];
767       v[2].p[1] = v[0].p[1];
768       v[3].p[1] = v[0].p[1];
769       break;
770     case PLANE_YZ0:
771     case PLANE_YZ1:
772       v[0].p[0] = backface;
773       v[1].p[0] = v[0].p[0];
774       v[2].p[0] = v[0].p[0];
775       v[3].p[0] = v[0].p[0];
776       break;
777     default:
778       v[0].p[2] = backface;
779       v[1].p[2] = v[0].p[2];
780       v[2].p[2] = v[0].p[2];
781       v[3].p[2] = v[0].p[2];
782     }
783 #ifndef ISOMETRIC
784     project(&v[3]);
785 #endif
786     Scale(rc,v[3],&pt[0]);
787     g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
788     g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
789     for(i=0; i<3; i++)
790     {
791 #ifndef ISOMETRIC
792       project(&v[i]);
793 #endif
794       Scale(rc,v[i],&pt[1]);
795       g_GLTable.m_pfn_qglVertex2i (pt[1].x, pt[1].y);
796     }
797     g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
798     g_GLTable.m_pfn_qglEnd ();
799   }
800
801   g_GLTable.m_pfn_qglLineWidth (1);
802   g_GLTable.m_pfn_qglColor3f (0, 1, 0);
803   g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
804
805 #ifdef ISOMETRIC
806   // Draw small depiction of coordinate axes
807   pt[0].x = rc.right  - cxChar   - cxChar/2 -  cyChar;
808   pt[0].y = rc.bottom - cyChar/2 - cxChar/2;
809   pt[1].x = pt[0].x + (int)(cyChar*COSXA);
810   pt[1].y = pt[0].y - (int)(cyChar*SINXA);
811   MoveToEx(hdc,pt[0].x,pt[0].y,NULL);
812   LineTo(hdc,pt[1].x,pt[1].y);
813   SetTextAlign(hdc,TA_LEFT | TA_TOP);
814   TextOut(hdc,pt[1].x,pt[1].y-cyChar/2,"X",1);
815   pt[1].x = pt[0].x - (int)(cyChar*COSYA);
816   pt[1].y = pt[0].y - (int)(cyChar*SINYA);
817   MoveToEx(hdc,pt[0].x,pt[0].y,NULL);
818   LineTo(hdc,pt[1].x,pt[1].y);
819   SetTextAlign(hdc,TA_RIGHT | TA_TOP);
820   TextOut(hdc,pt[1].x,pt[1].y-cyChar/2,"Y",1);
821   pt[1].x = pt[0].x;
822   pt[1].y = pt[0].y - cyChar;
823   MoveToEx(hdc,pt[0].x,pt[0].y,NULL);
824   LineTo(hdc,pt[1].x,pt[1].y);
825   SetTextAlign(hdc,TA_CENTER | TA_BOTTOM);
826   TextOut(hdc,pt[1].x,pt[1].y,"Z",1);
827 #else
828   L = 2*(double)cyChar/SF;
829   v[0].p[0] = 0.;
830   v[0].p[1] = 0.;
831   v[0].p[2] = 0.;
832   v[1].p[0] = L;
833   v[1].p[1] = 0.;
834   v[1].p[2] = 0.;
835   v[2].p[0] = 0.;
836   v[2].p[1] = L;
837   v[2].p[2] = 0.;
838   v[3].p[0] = 0.;
839   v[3].p[1] = 0.;
840   v[3].p[2] = L;
841   for(i=0; i<=3; i++)
842   {
843     project(&v[i]);
844     Scale(rc,v[i],&pt[i]);
845   }
846   for(i=1; i<=3; i++)
847   {
848     pt[i].x += -pt[0].x + rc.right  - 2*cyChar;
849     pt[i].y += -pt[0].y + rc.bottom + 2*cyChar;
850   }
851   pt[0].x = rc.right  - 2*cyChar;
852   pt[0].y = rc.bottom + 2*cyChar;
853
854   for(i=1; i<=3; i++)
855   {
856     g_GLTable.m_pfn_qglBegin (GL_LINES);
857     g_GLTable.m_pfn_qglVertex2i (pt[0].x, pt[0].y);
858     g_GLTable.m_pfn_qglVertex2i (pt[i].x, pt[i].y);
859     g_GLTable.m_pfn_qglEnd ();
860     texfont_write (axis[i-1], pt[i].x-cxChar/2,pt[i].y+cyChar/2);
861   }
862 #endif
863
864   // Draw player model's bounding box in red to give a sense of scale
865   // PEN_RED
866         g_GLTable.m_pfn_qglLineWidth (2);
867         g_GLTable.m_pfn_qglColor3f (1, 0, 0);
868         g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
869
870   switch(Plane)
871   {
872   case PLANE_XY1:
873     v[0].p[0] = xyz[NH/2][NV/2].p[0] + PlayerBox[Game].x[0];
874     v[0].p[1] = xyz[NH/2][NV/2].p[1] + PlayerBox[Game].y[0];
875     v[0].p[2] = zmin - PlayerBox[Game].z[0] - 32;
876     break;
877   case PLANE_XZ0:
878     v[0].p[0] = (xmax+xmin)/2 + PlayerBox[Game].x[0];
879     v[0].p[1] = ymax+64;
880     v[0].p[2] = zmin;
881     break;
882   case PLANE_XZ1:
883     v[0].p[0] = (xmax+xmin)/2 + PlayerBox[Game].x[0];
884     v[0].p[1] = ymin-64;
885     v[0].p[2] = zmin;
886     break;
887   case PLANE_YZ0:
888     v[0].p[0] = xmax+64;
889     v[0].p[1] = (ymax+ymin)/2 + PlayerBox[Game].y[0];
890     v[0].p[2] = zmin;
891     break;
892   case PLANE_YZ1:
893     v[0].p[0] = xmin-64;
894     v[0].p[1] = (ymax+ymin)/2 + PlayerBox[Game].y[0];
895     v[0].p[2] = zmin;
896     break;
897   default:
898     // Put player on a node. For patches, put on an even numbered node.
899     if(Game==QUAKE3 && UsePatches!=0)
900     {
901       if(NH > 2)
902         x = Hll + dh * (int)(NH/2 + 1);
903       else
904         x = Hll + dh * (int)(NH/2);
905       if(NV > 2)
906         y = Vll + dv * (int)(NV/2 + 1);
907       else
908         y = Vll + dv * (int)(NV/2);
909     }
910     else
911     {
912       if(NH > 1)
913         x = Hll + dh * (int)(NH/2);
914       else
915         x = Hll + dh/2;
916       if(NV > 1)
917         y = Vll + dv * (int)(NV/2);
918       else
919         y = Vll + dv/2;
920     }
921 //              x = (Hll+Hur)/2.;
922 //              y = (Vll+Vur)/2.;
923     v[0].p[0] = x + PlayerBox[Game].x[0];
924     v[0].p[1] = y + PlayerBox[Game].y[0];
925     v[0].p[2] = PlayerStartZ(x,y) + PlayerBox[Game].z[0] + 8; // add 8 cuz I'm a pessimist
926   }
927   v[1].p[0] = v[0].p[0] + PlayerBox[Game].x[1] - PlayerBox[Game].x[0];
928   v[1].p[1] = v[0].p[1];
929   v[1].p[2] = v[0].p[2];
930   v[2].p[0] = v[1].p[0];
931   v[2].p[1] = v[1].p[1] + PlayerBox[Game].y[1] - PlayerBox[Game].y[0];
932   v[2].p[2] = v[0].p[2];
933   v[3].p[0] = v[0].p[0];
934   v[3].p[1] = v[2].p[1];
935   v[3].p[2] = v[0].p[2];
936   VectorCopy(v[0].p,v[4].p);
937   VectorCopy(v[1].p,v[5].p);
938   VectorCopy(v[2].p,v[6].p);
939   VectorCopy(v[3].p,v[7].p);
940   v[4].p[2] += PlayerBox[Game].z[1] - PlayerBox[Game].z[0];
941   v[5].p[2] += PlayerBox[Game].z[1] - PlayerBox[Game].z[0];
942   v[6].p[2] += PlayerBox[Game].z[1] - PlayerBox[Game].z[0];
943   v[7].p[2] += PlayerBox[Game].z[1] - PlayerBox[Game].z[0];
944   for(i=0; i<=7; i++)
945   {
946 #ifndef ISOMETRIC
947     project(&v[i]);
948 #endif
949     Scale(rc,v[i],&pt[i]);
950   }
951   g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
952   g_GLTable.m_pfn_qglVertex2i (pt[3].x, pt[3].y);
953   for(i=0; i<=3; i++)
954     g_GLTable.m_pfn_qglVertex2i (pt[i].x, pt[i].y);
955   g_GLTable.m_pfn_qglEnd ();
956   g_GLTable.m_pfn_qglBegin (GL_LINE_STRIP);
957   g_GLTable.m_pfn_qglVertex2i (pt[7].x, pt[7].y);
958   for(i=4; i<=7; i++)
959     g_GLTable.m_pfn_qglVertex2i (pt[i].x, pt[i].y);
960   g_GLTable.m_pfn_qglEnd ();
961   g_GLTable.m_pfn_qglBegin (GL_LINES);
962   for(i=0; i<=3; i++)
963   {
964     g_GLTable.m_pfn_qglVertex2i (pt[i].x,pt[i].y);
965     g_GLTable.m_pfn_qglVertex2i (pt[i+4].x,pt[i+4].y);
966   }
967   g_GLTable.m_pfn_qglEnd ();
968
969   g_GLTable.m_pfn_qglLineWidth (1);
970   g_GLTable.m_pfn_qglColor3f (0, 1, 0);
971   g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
972 }
973 //=============================================================
974 void DrawGrid(Rect rc)
975 {
976   int        i, j, k;
977   double     h,w,x,y;
978   Point      pt[2];
979   Rect       rcBox;
980
981   w = (double)(rc.right-rc.left+1) - cxChar;
982   h = (double)(rc.top-rc.bottom+1) - cxChar - cyChar;
983
984   SFG = w/(Hur-Hll);
985   SFG = min(SFG, h/(Vur-Vll));
986
987   // Center drawing
988   X0G = (int)(rc.left + rc.right - (int)(SFG*(Hur-Hll)))/2;
989   Y0G = (int)(rc.top + rc.bottom + cyChar - (int)(SFG*(Vur-Vll)))/2;
990
991   g_GLTable.m_pfn_qglLineWidth (2);
992   g_GLTable.m_pfn_qglColor3f (0, 1, 0);
993   g_GLTable.m_pfn_qglDisable (GL_LINE_STIPPLE);
994
995   pt[0].y = Y0G;
996   pt[1].y = Y0G + (int)(SFG*(Vur-Vll));
997   g_GLTable.m_pfn_qglBegin (GL_LINES);
998   for(i=0; i<=NH; i++)
999   {
1000     x = Hll + i * dh;
1001     pt[0].x = X0G + (int)(SFG*(x-Hll));
1002     g_GLTable.m_pfn_qglVertex2i(pt[0].x, pt[0].y);
1003     g_GLTable.m_pfn_qglVertex2i(pt[0].x, pt[1].y);
1004   }
1005   g_GLTable.m_pfn_qglEnd ();
1006   pt[0].x = X0G;
1007   pt[1].x = X0G + (int)(SFG*(Hur-Hll));
1008   g_GLTable.m_pfn_qglBegin (GL_LINES);
1009   for(i=0; i<=NV; i++)
1010   {
1011     y = Vll + i * dv;
1012     pt[0].y = Y0G + (int)(SFG*(Vur-y));
1013     g_GLTable.m_pfn_qglVertex2i (pt[0].x,pt[0].y);
1014     g_GLTable.m_pfn_qglVertex2i (pt[1].x,pt[0].y);
1015   }
1016   g_GLTable.m_pfn_qglEnd ();
1017
1018   g_GLTable.m_pfn_qglLineWidth (1);
1019
1020   // Draw axes
1021   pt[0].x = rc.right  - cyChar - cxChar - cyChar/2;
1022   pt[0].y = rc.bottom + cyChar/2;
1023   pt[1].x = pt[0].x + cyChar;
1024   pt[1].y = pt[0].y;
1025   g_GLTable.m_pfn_qglBegin (GL_LINES);
1026   g_GLTable.m_pfn_qglVertex2i (pt[0].x,pt[0].y);
1027   g_GLTable.m_pfn_qglVertex2i (pt[1].x,pt[1].y);
1028   g_GLTable.m_pfn_qglEnd ();
1029   switch(Plane)
1030   {
1031   case PLANE_YZ0:
1032   case PLANE_YZ1:
1033     texfont_write ("Y", pt[1].x, pt[1].y+cyChar/2);
1034     break;
1035   default:
1036     texfont_write ("X", pt[1].x, pt[1].y+cyChar/2);
1037   }
1038   pt[1].x = pt[0].x;
1039   pt[1].y = pt[0].y + cyChar;
1040   g_GLTable.m_pfn_qglBegin (GL_LINES);
1041   g_GLTable.m_pfn_qglVertex2i (pt[0].x,pt[0].y);
1042   g_GLTable.m_pfn_qglVertex2i (pt[1].x,pt[1].y);
1043   g_GLTable.m_pfn_qglEnd ();
1044   switch(Plane)
1045   {
1046   case PLANE_XY0:
1047   case PLANE_XY1:
1048     texfont_write ("Y", pt[1].x-cyChar/2, pt[1].y+cyChar);
1049     break;
1050   default:
1051     texfont_write ("Z", pt[1].x-cyChar/2, pt[1].y+cyChar);
1052   }
1053
1054   // Denote fixed points with a 5x5 red rectangle
1055   for(i=0; i<=NH; i++)
1056   {
1057     for(j=0; j<=NV; j++)
1058     {
1059       if(xyz[i][j].fixed)
1060       {
1061         x = Hll + i*dh;
1062         y = Vll + j*dv;
1063         rcBox.left   = X0G + (int)(SFG*(x-Hll)) - 2;
1064         rcBox.top    = Y0G + (int)(SFG*(Vur-y)) + 2;
1065         rcBox.right  = rcBox.left + 5;
1066         rcBox.bottom = rcBox.top  - 5;
1067
1068         DRAW_QUAD (rcBox, 1,0,0);
1069       }
1070     }
1071   }
1072
1073   // Denote currently selected point with a 5x5 green rectangle
1074   if (NumVerticesSelected)
1075   {
1076     for(k=0; k<NumVerticesSelected; k++)
1077     {
1078       x = Hll + Vertex[k].i*dh;
1079       y = Vll + Vertex[k].j*dv;
1080       rcBox.left   = X0G + (int)(SFG*(x-Hll)) - 2;
1081       rcBox.top    = Y0G + (int)(SFG*(Vur-y)) + 2;
1082       rcBox.right  = rcBox.left + 5;
1083       rcBox.bottom = rcBox.top  - 5;
1084
1085       DRAW_QUAD (rcBox, 0,1,0);
1086     }
1087   }
1088
1089   // Unmovable vertices
1090   for(i=0; i<=NH; i++)
1091   {
1092     for(j=0; j<=NV; j++)
1093     {
1094       if(!CanEdit(i,j))
1095       {
1096         x = Hll + i*dh;
1097         y = Vll + j*dv;
1098         rcBox.left   = X0G + (int)(SFG*(x-Hll)) - 2;
1099         rcBox.top    = Y0G + (int)(SFG*(Vur-y)) + 2;
1100         rcBox.right  = rcBox.left + 5;
1101         rcBox.bottom = rcBox.top  - 5;
1102
1103         DRAW_QUAD (rcBox, 1,1,0);
1104       }
1105     }
1106   }
1107
1108   // Legend
1109   rcBox.left   = rc.left + cxChar/2 - 2;
1110   rcBox.top    = rc.top  - cyChar/2 - 2;
1111   rcBox.right  = rcBox.left + 5;
1112   rcBox.bottom = rcBox.top  - 5;
1113   DRAW_QUAD (rcBox, 1,0,0);
1114   texfont_write ("Fixed points", rcBox.right+cxChar,rcBox.top-4+cyChar/2);
1115
1116   rcBox.top    -= cyChar;
1117   rcBox.bottom -= cyChar;
1118   DRAW_QUAD (rcBox, 1,1,0);
1119   texfont_write ("Not movable", rcBox.right+cxChar, rcBox.top-4+cyChar/2);
1120
1121   rcBox.top    -= cyChar;
1122   rcBox.bottom -= cyChar;
1123   DRAW_QUAD (rcBox, 0,1,0);
1124   texfont_write ("Selected", rcBox.right+cxChar, rcBox.top-4+cyChar/2);
1125 }
1126
1127 //=============================================================
1128 void GetScaleFactor(Rect rc)
1129 {
1130 #ifdef ISOMETRIC
1131         double      h, w;
1132
1133         w = (double)(rc.right-rc.left+1) - cxChar;
1134         h = (double)(rc.top-rc.bottom+1) - cxChar;
1135
1136         SF = w/( (XHi-XLo)*COSXA + (YHi-YLo)*COSYA );
1137         SF = min(SF, h/( (XHi-XLo)*SINXA + (YHi-YLo)*SINYA + ZHi-ZLo ) );
1138         // Center drawing
1139         X0 = (int)(rc.left + rc.right - (int)(SF*( (XHi-XLo)*COSXA + (YHi-YLo)*COSYA )) )/2;
1140         Y0 = (int)(rc.top + rc.bottom - (int)(SF*( (XHi-XLo)*SINXA + (YHi-YLo)*SINYA + ZHi-ZLo) ))/2;
1141
1142 #else
1143         double      h, w;
1144
1145         w = (double)(rc.right-rc.left+1) - cxChar;
1146         h = (double)(rc.top-rc.bottom+1) - cxChar;
1147
1148         SF = w/(Hhi-Hlo);
1149         SF = min(SF, h/(Vhi-Vlo) );
1150         X0 = (int)(rc.left + rc.right - (int)(SF*(Hhi-Hlo)))/2;
1151         Y0 = (int)(rc.top + rc.bottom + (int)(SF*(Vhi-Vlo)))/2;
1152 #endif
1153 }
1154
1155 //=============================================================
1156 void Scale(Rect rc,XYZ xyz,Point *pt)
1157 {
1158
1159 #ifdef ISOMETRIC
1160
1161         pt[0].x = X0 + (int)(SF*( (xyz.p[0]-XLo)*COSXA +
1162                               (YHi-xyz.p[1])*COSYA   ));
1163         pt[0].y = Y0 + (int)(SF*(  ZHi-xyz.p[2] +
1164                                   (YHi-xyz.p[1])*SINYA +
1165                                                   (XHi-xyz.p[0])*SINXA   ));
1166 #else
1167         pt[0].x = X0 + (int)(SF*( xyz.pp[0] - Hlo ) );
1168         pt[0].y = Y0 - (int)(SF*( Vhi - xyz.pp[1] ) );
1169 #endif
1170
1171 }
1172
1173 #ifndef ISOMETRIC
1174 /* ======================================================================= */
1175 void project(XYZ *v)
1176 {
1177         // project a 3D point (x,y,z) onto view plane
1178         double x, y, z, xa, ya, za;
1179
1180         x = v->p[0];
1181         y = v->p[1];
1182         z = v->p[2];
1183
1184         // yaw
1185         xa = ct[0]*x - st[0]*z;
1186         za = st[0]*x + ct[0]*z;
1187
1188         // roll
1189         x  = ct[1]*xa + st[1]*y;
1190         ya = ct[1]*y  - st[1]*xa;
1191
1192         // azimuth
1193         z  = ct[2]*za - st[2]*ya;
1194         y  = ct[2]*ya + st[2]*za;
1195
1196         // horizontal and vertical projections:
1197 //      v->pp[0] = D*x/z;
1198 //      v->pp[1] = D*y/z;
1199         v->pp[0] = -y;
1200         v->pp[1] =  x;
1201         v->pp[2] =  z;
1202
1203         // NOTE: if perspective transformation is desired,
1204         // set "persp" to the range from the surface,
1205         // then:
1206         // v->projected_h = -v->projected_h * persp/(v->projected_z-persp);
1207         // v->projected_v = -v->projected_v * persp/(v->projected_z-persp);
1208 }
1209 /*=======================================================================*/
1210 void evaluate()
1211 {
1212         int i, j;
1213         XYZ v[4];
1214         
1215         if(elevation > PI) elevation -= 2.*PI;
1216         roll = elevation * sin(azimuth);
1217         yaw  = 1.5*PI + elevation*cos(azimuth);
1218
1219         //      Find angles from midpoint to viewpoint:
1220         st[0] = sin(yaw);
1221         st[1] = sin(roll);
1222         st[2] = sin(azimuth);
1223         ct[0] = cos(yaw);
1224         ct[1] = cos(roll);
1225         ct[2] = cos(azimuth);
1226
1227         for(i=0; i<=NH; i++)
1228         {
1229                 for(j=0; j<=NV; j++)
1230                 {
1231                         project(&xyz[i][j]);
1232                 }
1233         }
1234
1235         Hhi = xyz[0][0].pp[0];
1236         Hlo = Hhi;
1237         Vhi = xyz[0][0].pp[1];
1238         Vlo = Vhi;
1239         for(i=0; i<=NH; i++)
1240         {
1241                 for(j=0; j<=NV; j++)
1242                 {
1243                         Hlo = min(Hlo,xyz[i][j].pp[0]);
1244                         Hhi = max(Hhi,xyz[i][j].pp[0]);
1245                         Vlo = min(Vlo,xyz[i][j].pp[1]);
1246                         Vhi = max(Vhi,xyz[i][j].pp[1]);
1247                 }
1248         }
1249
1250         // Include backface in min-max
1251         VectorCopy(xyz[ 0][ 0].p,v[0].p);
1252         VectorCopy(xyz[NH][ 0].p,v[1].p);
1253         VectorCopy(xyz[NH][NV].p,v[2].p);
1254         VectorCopy(xyz[ 0][NV].p,v[3].p);
1255         switch(Plane)
1256         {
1257         case PLANE_XZ0:
1258         case PLANE_XZ1:
1259                 v[0].p[1] = backface;
1260                 v[1].p[1] = v[0].p[1];
1261                 v[2].p[1] = v[0].p[1];
1262                 v[3].p[1] = v[0].p[1];
1263                 break;
1264         case PLANE_YZ0:
1265         case PLANE_YZ1:
1266                 v[0].p[0] = backface;
1267                 v[1].p[0] = v[0].p[0];
1268                 v[2].p[0] = v[0].p[0];
1269                 v[3].p[0] = v[0].p[0];
1270                 break;
1271         default:
1272                 v[0].p[2] = backface;
1273                 v[1].p[2] = v[0].p[2];
1274                 v[2].p[2] = v[0].p[2];
1275                 v[3].p[2] = v[0].p[2];
1276         }
1277         for(i=0; i<=3; i++)
1278         {
1279                 project(&v[i]);
1280                 Hlo = min(Hlo,v[i].pp[0]);
1281                 Hhi = max(Hhi,v[i].pp[0]);
1282                 Vlo = min(Vlo,v[i].pp[1]);
1283                 Vhi = max(Vhi,v[i].pp[1]);
1284         }
1285
1286 }
1287 #endif