2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
25 // Leonardo Zide (leo@lokigames.com)
28 #include "surfacedialog.h"
30 #include "debugging/debugging.h"
33 #include "iscenegraph.h"
36 #include "iselection.h"
38 #include <gtk/gtkhbox.h>
39 #include <gtk/gtkvbox.h>
40 #include <gtk/gtkframe.h>
41 #include <gtk/gtklabel.h>
42 #include <gtk/gtktable.h>
43 #include <gtk/gtkbutton.h>
44 #include <gtk/gtkspinbutton.h>
45 #include <gdk/gdkkeysyms.h>
46 #include <gtk/gtkcheckbutton.h> //Shamus: For Textool
48 #include "signal/isignal.h"
49 #include "generic/object.h"
50 #include "math/vector.h"
51 #include "texturelib.h"
52 #include "shaderlib.h"
55 #include "gtkutil/idledraw.h"
56 #include "gtkutil/dialog.h"
57 #include "gtkutil/entry.h"
58 #include "gtkutil/nonmodal.h"
59 #include "gtkutil/pointer.h"
60 #include "gtkutil/glwidget.h" //Shamus: For Textool
61 #include "gtkutil/button.h"
64 #include "patchmanip.h"
65 #include "brushmanip.h"
66 #include "patchdialog.h"
67 #include "preferences.h"
68 #include "brush_primit.h"
70 #include "mainframe.h"
73 #include "brush.h" //Shamus: for Textool
76 #include "stream/stringstream.h"
78 #include "textureentry.h"
80 //NOTE: Proper functioning of Textool currently requires that the "#if 1" lines in
81 // brush_primit.h be changed to "#if 0". add/removeScale screws this up ATM. :-)
82 // Plus, Radiant seems to work just fine without that stuff. ;-)
84 #define TEXTOOL_ENABLED 0
91 //Shamus: Textool function prototypes
92 gboolean size_allocate(GtkWidget *, GtkAllocation *, gpointer);
93 gboolean expose(GtkWidget *, GdkEventExpose *, gpointer);
94 gboolean button_press(GtkWidget *, GdkEventButton *, gpointer);
95 gboolean button_release(GtkWidget *, GdkEventButton *, gpointer);
96 gboolean motion(GtkWidget *, GdkEventMotion *, gpointer);
97 void flipX(GtkToggleButton *, gpointer);
98 void flipY(GtkToggleButton *, gpointer);
100 //End Textool function prototypes
102 //Shamus: Textool globals
103 GtkWidget * g_textoolWin;
104 //End Textool globals
108 gtk_widget_queue_draw(g_textoolWin);
115 inline void spin_button_set_step(GtkSpinButton* spin, gfloat step)
118 gtk_spin_button_get_adjustment(spin)->step_increment = step;
120 GValue gvalue = GValue_default();
121 g_value_init(&gvalue, G_TYPE_DOUBLE);
122 g_value_set_double(&gvalue, step);
123 g_object_set(G_OBJECT(gtk_spin_button_get_adjustment(spin)), "step-increment", &gvalue, NULL);
131 GtkSpinButton* m_spin;
133 Increment(float& f) : m_f(f), m_spin(0), m_entry(0)
138 entry_set_float(m_entry, m_f);
140 typedef MemberCaller<Increment, &Increment::cancel> CancelCaller;
143 m_f = static_cast<float>(entry_get_float(m_entry));
144 spin_button_set_step(m_spin, m_f);
146 typedef MemberCaller<Increment, &Increment::apply> ApplyCaller;
149 void SurfaceInspector_GridChange();
151 class SurfaceInspector : public Dialog
153 GtkWindow* BuildDialog();
155 NonModalEntry m_textureEntry;
156 NonModalSpinner m_hshiftSpinner;
157 NonModalEntry m_hshiftEntry;
158 NonModalSpinner m_vshiftSpinner;
159 NonModalEntry m_vshiftEntry;
160 NonModalSpinner m_hscaleSpinner;
161 NonModalEntry m_hscaleEntry;
162 NonModalSpinner m_vscaleSpinner;
163 NonModalEntry m_vscaleEntry;
164 NonModalSpinner m_rotateSpinner;
165 NonModalEntry m_rotateEntry;
169 GtkCheckButton* m_surfaceFlags[32];
170 GtkCheckButton* m_contentFlags[32];
172 NonModalEntry m_valueEntry;
173 GtkEntry* m_valueEntryWidget;
175 WindowPositionTracker m_positionTracker;
176 WindowPositionTrackerImportStringCaller m_importPosition;
177 WindowPositionTrackerExportStringCaller m_exportPosition;
180 float m_fitHorizontal;
183 Increment m_hshiftIncrement;
184 Increment m_vshiftIncrement;
185 Increment m_hscaleIncrement;
186 Increment m_vscaleIncrement;
187 Increment m_rotateIncrement;
191 m_textureEntry(ApplyShaderCaller(*this), UpdateCaller(*this)),
192 m_hshiftSpinner(ApplyTexdefCaller(*this), UpdateCaller(*this)),
193 m_hshiftEntry(Increment::ApplyCaller(m_hshiftIncrement), Increment::CancelCaller(m_hshiftIncrement)),
194 m_vshiftSpinner(ApplyTexdefCaller(*this), UpdateCaller(*this)),
195 m_vshiftEntry(Increment::ApplyCaller(m_vshiftIncrement), Increment::CancelCaller(m_vshiftIncrement)),
196 m_hscaleSpinner(ApplyTexdefCaller(*this), UpdateCaller(*this)),
197 m_hscaleEntry(Increment::ApplyCaller(m_hscaleIncrement), Increment::CancelCaller(m_hscaleIncrement)),
198 m_vscaleSpinner(ApplyTexdefCaller(*this), UpdateCaller(*this)),
199 m_vscaleEntry(Increment::ApplyCaller(m_vscaleIncrement), Increment::CancelCaller(m_vscaleIncrement)),
200 m_rotateSpinner(ApplyTexdefCaller(*this), UpdateCaller(*this)),
201 m_rotateEntry(Increment::ApplyCaller(m_rotateIncrement), Increment::CancelCaller(m_rotateIncrement)),
202 m_idleDraw(UpdateCaller(*this)),
203 m_valueEntry(ApplyFlagsCaller(*this), UpdateCaller(*this)),
204 m_importPosition(m_positionTracker),
205 m_exportPosition(m_positionTracker),
206 m_hshiftIncrement(g_si_globals.shift[0]),
207 m_vshiftIncrement(g_si_globals.shift[1]),
208 m_hscaleIncrement(g_si_globals.scale[0]),
209 m_vscaleIncrement(g_si_globals.scale[1]),
210 m_rotateIncrement(g_si_globals.rotate)
214 m_positionTracker.setPosition(c_default_window_pos);
217 void constructWindow(GtkWindow* main_window)
219 m_parent = main_window;
221 AddGridChangeCallback(FreeCaller<SurfaceInspector_GridChange>());
229 return GTK_WIDGET_VISIBLE(const_cast<GtkWindow*>(GetWidget()));
235 m_idleDraw.queueDraw();
240 typedef MemberCaller<SurfaceInspector, &SurfaceInspector::Update> UpdateCaller;
242 typedef MemberCaller<SurfaceInspector, &SurfaceInspector::ApplyShader> ApplyShaderCaller;
244 typedef MemberCaller<SurfaceInspector, &SurfaceInspector::ApplyTexdef> ApplyTexdefCaller;
246 typedef MemberCaller<SurfaceInspector, &SurfaceInspector::ApplyFlags> ApplyFlagsCaller;
251 SurfaceInspector* g_SurfaceInspector;
253 inline SurfaceInspector& getSurfaceInspector()
255 ASSERT_NOTNULL(g_SurfaceInspector);
256 return *g_SurfaceInspector;
260 void SurfaceInspector_constructWindow(GtkWindow* main_window)
262 getSurfaceInspector().constructWindow(main_window);
264 void SurfaceInspector_destroyWindow()
266 getSurfaceInspector().destroyWindow();
269 void SurfaceInspector_queueDraw()
271 getSurfaceInspector().queueDraw();
276 CopiedString g_selectedShader;
277 TextureProjection g_selectedTexdef;
278 ContentsFlagsValue g_selectedFlags;
281 void SurfaceInspector_SetSelectedShader(const char* shader)
283 g_selectedShader = shader;
284 SurfaceInspector_queueDraw();
287 void SurfaceInspector_SetSelectedTexdef(const TextureProjection& projection)
289 g_selectedTexdef = projection;
290 SurfaceInspector_queueDraw();
293 void SurfaceInspector_SetSelectedFlags(const ContentsFlagsValue& flags)
295 g_selectedFlags = flags;
296 SurfaceInspector_queueDraw();
299 static bool s_texture_selection_dirty = false;
301 void SurfaceInspector_updateSelection()
303 s_texture_selection_dirty = true;
304 SurfaceInspector_queueDraw();
307 if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES)
309 TexTool::queueDraw();
310 //globalOutputStream() << "textool texture changed..\n";
315 void SurfaceInspector_SelectionChanged(const Selectable& selectable)
317 SurfaceInspector_updateSelection();
320 void SurfaceInspector_SetCurrent_FromSelected()
322 if(s_texture_selection_dirty == true)
324 s_texture_selection_dirty = false;
325 if(!g_SelectedFaceInstances.empty())
327 TextureProjection projection;
328 //This *may* be the point before it fucks up... Let's see!
329 //Yep, there was a call to removeScale in there...
330 Scene_BrushGetTexdef_Component_Selected(GlobalSceneGraph(), projection);
331 SurfaceInspector_SetSelectedTexdef(projection);
334 Scene_BrushGetShader_Component_Selected(GlobalSceneGraph(), name);
335 if(string_not_empty(name.c_str()))
337 SurfaceInspector_SetSelectedShader(name.c_str());
340 ContentsFlagsValue flags;
341 Scene_BrushGetFlags_Component_Selected(GlobalSceneGraph(), flags);
342 SurfaceInspector_SetSelectedFlags(flags);
346 TextureProjection projection;
347 Scene_BrushGetTexdef_Selected(GlobalSceneGraph(), projection);
348 SurfaceInspector_SetSelectedTexdef(projection);
351 Scene_BrushGetShader_Selected(GlobalSceneGraph(), name);
352 if(string_empty(name.c_str()))
354 Scene_PatchGetShader_Selected(GlobalSceneGraph(), name);
356 if(string_not_empty(name.c_str()))
358 SurfaceInspector_SetSelectedShader(name.c_str());
361 ContentsFlagsValue flags(0, 0, 0, false);
362 Scene_BrushGetFlags_Selected(GlobalSceneGraph(), flags);
363 SurfaceInspector_SetSelectedFlags(flags);
368 const char* SurfaceInspector_GetSelectedShader()
370 SurfaceInspector_SetCurrent_FromSelected();
371 return g_selectedShader.c_str();
374 const TextureProjection& SurfaceInspector_GetSelectedTexdef()
376 SurfaceInspector_SetCurrent_FromSelected();
377 return g_selectedTexdef;
380 const ContentsFlagsValue& SurfaceInspector_GetSelectedFlags()
382 SurfaceInspector_SetCurrent_FromSelected();
383 return g_selectedFlags;
389 ===================================================
393 ===================================================
396 si_globals_t g_si_globals;
399 // make the shift increments match the grid settings
400 // the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size
401 // this depends on a scale value if you have selected a particular texture on which you want it to work:
402 // we move the textures in pixels, not world units. (i.e. increment values are in pixel)
403 // depending on the texture scale it doesn't take the same amount of pixels to move of GetGridSize()
404 // increment * scale = gridsize
405 // hscale and vscale are optional parameters, if they are zero they will be set to the default scale
406 // NOTE: the default scale depends if you are using BP mode or regular.
407 // For regular it's 0.5f (128 pixels cover 64 world units), for BP it's simply 1.0f
409 void DoSnapTToGrid(float hscale, float vscale)
411 g_si_globals.shift[0] = static_cast<float>(float_to_integer(static_cast<float>(GetGridSize()) / hscale));
412 g_si_globals.shift[1] = static_cast<float>(float_to_integer(static_cast<float>(GetGridSize()) / vscale));
413 getSurfaceInspector().queueDraw();
416 void SurfaceInspector_GridChange()
418 if (g_si_globals.m_bSnapTToGrid)
419 DoSnapTToGrid(Texdef_getDefaultTextureScale(), Texdef_getDefaultTextureScale());
422 // make the shift increments match the grid settings
423 // the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size
424 // this depends on the current texture scale used?
425 // we move the textures in pixels, not world units. (i.e. increment values are in pixel)
426 // depending on the texture scale it doesn't take the same amount of pixels to move of GetGridSize()
427 // increment * scale = gridsize
428 static void OnBtnMatchGrid(GtkWidget *widget, gpointer data)
430 float hscale, vscale;
431 hscale = static_cast<float>(gtk_spin_button_get_value_as_float(getSurfaceInspector().m_hscaleIncrement.m_spin));
432 vscale = static_cast<float>(gtk_spin_button_get_value_as_float(getSurfaceInspector().m_vscaleIncrement.m_spin));
434 if (hscale == 0.0f || vscale == 0.0f)
436 globalOutputStream() << "ERROR: unexpected scale == 0.0f\n";
440 DoSnapTToGrid (hscale, vscale);
443 // DoSurface will always try to show the surface inspector
444 // or update it because something new has been selected
445 // Shamus: It does get called when the SI is hidden, but not when you select something new. ;-)
446 void DoSurface (void)
448 if(getSurfaceInspector().GetWidget() == 0)
450 getSurfaceInspector().Create();
453 getSurfaceInspector().Update();
454 getSurfaceInspector().importData();
455 getSurfaceInspector().ShowDlg();
458 void SurfaceInspector_toggleShown()
460 if (getSurfaceInspector().visible())
462 getSurfaceInspector().HideDlg();
470 void SurfaceInspector_FitTexture()
472 UndoableCommand undo("textureAutoFit");
473 Select_FitTexture(getSurfaceInspector().m_fitHorizontal, getSurfaceInspector().m_fitVertical);
476 static void OnBtnPatchdetails(GtkWidget *widget, gpointer data)
478 Scene_PatchCapTexture_Selected(GlobalSceneGraph());
481 static void OnBtnPatchnatural(GtkWidget *widget, gpointer data)
483 Scene_PatchNaturalTexture_Selected(GlobalSceneGraph());
486 static void OnBtnPatchreset(GtkWidget *widget, gpointer data)
490 if (DoTextureLayout (&fx, &fy) == eIDOK)
492 Scene_PatchTileTexture_Selected(GlobalSceneGraph(), fx, fy);
496 static void OnBtnPatchFit(GtkWidget *widget, gpointer data)
498 Scene_PatchTileTexture_Selected(GlobalSceneGraph(), 1, 1);
501 static void OnBtnAxial(GtkWidget *widget, gpointer data)
503 //globalOutputStream() << "--> [OnBtnAxial]...\n";
504 UndoableCommand undo("textureDefault");
505 TextureProjection projection;
506 //globalOutputStream() << " TexDef_Construct_Default()...\n";
507 TexDef_Construct_Default(projection);
508 //globalOutputStream() << " Select_SetTexdef()...\n";
513 if (g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES)
515 // Scale up texture width/height if in BP mode...
516 //NOTE: This may not be correct any more! :-P
517 if (!g_SelectedFaceInstances.empty())
519 Face & face = g_SelectedFaceInstances.last().getFace();
520 float x = face.getShader().m_state->getTexture().width;
521 float y = face.getShader().m_state->getTexture().height;
522 projection.m_brushprimit_texdef.coords[0][0] /= x;
523 projection.m_brushprimit_texdef.coords[0][1] /= y;
524 projection.m_brushprimit_texdef.coords[1][0] /= x;
525 projection.m_brushprimit_texdef.coords[1][1] /= y;
530 Select_SetTexdef(projection);
533 static void OnBtnFaceFit(GtkWidget *widget, gpointer data)
535 getSurfaceInspector().exportData();
536 SurfaceInspector_FitTexture();
539 typedef const char* FlagName;
541 const FlagName surfaceflagNamesDefault[32] = {
576 const FlagName contentflagNamesDefault[32] = {
611 const char* getSurfaceFlagName(std::size_t bit)
613 const char* value = g_pGameDescription->getKeyValue(surfaceflagNamesDefault[bit]);
614 if(string_empty(value))
616 return surfaceflagNamesDefault[bit];
621 const char* getContentFlagName(std::size_t bit)
623 const char* value = g_pGameDescription->getKeyValue(contentflagNamesDefault[bit]);
624 if(string_empty(value))
626 return contentflagNamesDefault[bit];
632 // =============================================================================
633 // SurfaceInspector class
635 guint togglebutton_connect_toggled(GtkToggleButton* button, const Callback& callback)
637 return g_signal_connect_swapped(G_OBJECT(button), "toggled", G_CALLBACK(callback.getThunk()), callback.getEnvironment());
640 GtkWindow* SurfaceInspector::BuildDialog()
642 GtkWindow* window = create_floating_window("Surface Inspector", m_parent);
644 m_positionTracker.connect(window);
646 global_accel_connect_window(window);
648 window_connect_focus_in_clear_focus_widget(window);
652 // replaced by only the vbox:
653 GtkWidget* vbox = gtk_vbox_new (FALSE, 5);
654 gtk_widget_show (vbox);
655 gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(vbox));
656 gtk_container_set_border_width (GTK_CONTAINER (vbox), 5);
659 GtkWidget* hbox2 = gtk_hbox_new (FALSE, 5);
660 gtk_widget_show (hbox2);
661 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox2), FALSE, FALSE, 0);
664 GtkWidget* label = gtk_label_new ("Texture");
665 gtk_widget_show (label);
666 gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, TRUE, 0);
669 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
670 gtk_widget_show(GTK_WIDGET(entry));
671 gtk_box_pack_start(GTK_BOX(hbox2), GTK_WIDGET(entry), TRUE, TRUE, 0);
673 m_textureEntry.connect(entry);
674 GlobalTextureEntryCompletion::instance().connect(entry);
680 GtkWidget* table = gtk_table_new (6, 4, FALSE);
681 gtk_widget_show (table);
682 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0);
683 gtk_table_set_row_spacings(GTK_TABLE(table), 5);
684 gtk_table_set_col_spacings(GTK_TABLE(table), 5);
686 GtkWidget* label = gtk_label_new ("Horizontal shift");
687 gtk_widget_show (label);
688 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
689 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
690 (GtkAttachOptions) (GTK_FILL),
691 (GtkAttachOptions) (0), 0, 0);
694 GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, -8192, 8192, 2, 8, 8)), 0, 2));
695 m_hshiftIncrement.m_spin = spin;
696 m_hshiftSpinner.connect(spin);
697 gtk_widget_show(GTK_WIDGET(spin));
698 gtk_table_attach (GTK_TABLE(table), GTK_WIDGET(spin), 1, 2, 0, 1,
699 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
700 (GtkAttachOptions) (0), 0, 0);
701 gtk_widget_set_usize(GTK_WIDGET(spin), 60, -2);
704 GtkWidget* label = gtk_label_new ("Step");
705 gtk_widget_show (label);
706 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
707 gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1,
708 (GtkAttachOptions) (GTK_FILL),
709 (GtkAttachOptions) (0), 0, 0);
712 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
713 gtk_widget_show(GTK_WIDGET(entry));
714 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(entry), 3, 4, 0, 1,
715 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
716 (GtkAttachOptions) (0), 0, 0);
717 gtk_widget_set_usize(GTK_WIDGET(entry), 50, -2);
718 m_hshiftIncrement.m_entry = entry;
719 m_hshiftEntry.connect(entry);
722 GtkWidget* label = gtk_label_new ("Vertical shift");
723 gtk_widget_show (label);
724 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
725 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 1, 2,
726 (GtkAttachOptions) (GTK_FILL),
727 (GtkAttachOptions) (0), 0, 0);
730 GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, -8192, 8192, 2, 8, 8)), 0, 2));
731 m_vshiftIncrement.m_spin = spin;
732 m_vshiftSpinner.connect(spin);
733 gtk_widget_show(GTK_WIDGET(spin));
734 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(spin), 1, 2, 1, 2,
735 (GtkAttachOptions) (GTK_FILL),
736 (GtkAttachOptions) (0), 0, 0);
737 gtk_widget_set_usize(GTK_WIDGET(spin), 60, -2);
740 GtkWidget* label = gtk_label_new ("Step");
741 gtk_widget_show (label);
742 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
743 gtk_table_attach(GTK_TABLE(table), label, 2, 3, 1, 2,
744 (GtkAttachOptions) (GTK_FILL),
745 (GtkAttachOptions) (0), 0, 0);
748 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
749 gtk_widget_show(GTK_WIDGET(entry));
750 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(entry), 3, 4, 1, 2,
751 (GtkAttachOptions) (GTK_FILL),
752 (GtkAttachOptions) (0), 0, 0);
753 gtk_widget_set_usize(GTK_WIDGET(entry), 50, -2);
754 m_vshiftIncrement.m_entry = entry;
755 m_vshiftEntry.connect(entry);
758 GtkWidget* label = gtk_label_new ("Horizontal stretch");
759 gtk_widget_show (label);
760 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
761 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
762 (GtkAttachOptions) (GTK_FILL),
763 (GtkAttachOptions) (0), 0, 0);
766 GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, -8192, 8192, 2, 8, 8)), 0, 5));
767 m_hscaleIncrement.m_spin = spin;
768 m_hscaleSpinner.connect(spin);
769 gtk_widget_show(GTK_WIDGET(spin));
770 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(spin), 1, 2, 2, 3,
771 (GtkAttachOptions) (GTK_FILL),
772 (GtkAttachOptions) (0), 0, 0);
773 gtk_widget_set_usize(GTK_WIDGET(spin), 60, -2);
776 GtkWidget* label = gtk_label_new ("Step");
777 gtk_widget_show (label);
778 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
779 gtk_table_attach(GTK_TABLE(table), label, 2, 3, 2, 3,
780 (GtkAttachOptions) (GTK_FILL),
781 (GtkAttachOptions) (0), 2, 3);
784 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
785 gtk_widget_show(GTK_WIDGET(entry));
786 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(entry), 3, 4, 2, 3,
787 (GtkAttachOptions) (GTK_FILL),
788 (GtkAttachOptions) (0), 2, 3);
789 gtk_widget_set_usize(GTK_WIDGET(entry), 50, -2);
790 m_hscaleIncrement.m_entry = entry;
791 m_hscaleEntry.connect(entry);
794 GtkWidget* label = gtk_label_new ("Vertical stretch");
795 gtk_widget_show (label);
796 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
797 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 3, 4,
798 (GtkAttachOptions) (GTK_FILL),
799 (GtkAttachOptions) (0), 0, 0);
802 GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, -8192, 8192, 2, 8, 8)), 0, 5));
803 m_vscaleIncrement.m_spin = spin;
804 m_vscaleSpinner.connect(spin);
805 gtk_widget_show(GTK_WIDGET(spin));
806 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(spin), 1, 2, 3, 4,
807 (GtkAttachOptions) (GTK_FILL),
808 (GtkAttachOptions) (0), 0, 0);
809 gtk_widget_set_usize(GTK_WIDGET(spin), 60, -2);
812 GtkWidget* label = gtk_label_new ("Step");
813 gtk_widget_show (label);
814 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
815 gtk_table_attach(GTK_TABLE(table), label, 2, 3, 3, 4,
816 (GtkAttachOptions) (GTK_FILL),
817 (GtkAttachOptions) (0), 0, 0);
820 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
821 gtk_widget_show(GTK_WIDGET(entry));
822 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(entry), 3, 4, 3, 4,
823 (GtkAttachOptions) (GTK_FILL),
824 (GtkAttachOptions) (0), 0, 0);
825 gtk_widget_set_usize(GTK_WIDGET(entry), 50, -2);
826 m_vscaleIncrement.m_entry = entry;
827 m_vscaleEntry.connect(entry);
830 GtkWidget* label = gtk_label_new ("Rotate");
831 gtk_widget_show (label);
832 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
833 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 4, 5,
834 (GtkAttachOptions) (GTK_FILL),
835 (GtkAttachOptions) (0), 0, 0);
838 GtkSpinButton* spin = GTK_SPIN_BUTTON(gtk_spin_button_new(GTK_ADJUSTMENT(gtk_adjustment_new(0, -8192, 8192, 2, 8, 8)), 0, 2));
839 m_rotateIncrement.m_spin = spin;
840 m_rotateSpinner.connect(spin);
841 gtk_widget_show(GTK_WIDGET(spin));
842 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(spin), 1, 2, 4, 5,
843 (GtkAttachOptions) (GTK_FILL),
844 (GtkAttachOptions) (0), 0, 0);
845 gtk_widget_set_usize(GTK_WIDGET(spin), 60, -2);
846 gtk_spin_button_set_wrap(spin, TRUE);
849 GtkWidget* label = gtk_label_new ("Step");
850 gtk_widget_show (label);
851 gtk_misc_set_alignment (GTK_MISC (label), 0, 0);
852 gtk_table_attach(GTK_TABLE(table), label, 2, 3, 4, 5,
853 (GtkAttachOptions) (GTK_FILL),
854 (GtkAttachOptions) (0), 0, 0);
857 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
858 gtk_widget_show(GTK_WIDGET(entry));
859 gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(entry), 3, 4, 4, 5,
860 (GtkAttachOptions) (GTK_FILL),
861 (GtkAttachOptions) (0), 0, 0);
862 gtk_widget_set_usize(GTK_WIDGET(entry), 50, -2);
863 m_rotateIncrement.m_entry = entry;
864 m_rotateEntry.connect(entry);
868 GtkWidget* button = gtk_button_new_with_label ("Match Grid");
869 gtk_widget_show (button);
870 gtk_table_attach(GTK_TABLE(table), button, 2, 4, 5, 6,
871 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
872 (GtkAttachOptions) (0), 0, 0);
873 g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(OnBtnMatchGrid), 0);
878 GtkWidget* frame = gtk_frame_new ("Texturing");
879 gtk_widget_show (frame);
880 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(frame), FALSE, FALSE, 0);
882 GtkWidget* table = gtk_table_new (4, 4, FALSE);
883 gtk_widget_show (table);
884 gtk_container_add (GTK_CONTAINER (frame), table);
885 gtk_table_set_row_spacings(GTK_TABLE(table), 5);
886 gtk_table_set_col_spacings(GTK_TABLE(table), 5);
887 gtk_container_set_border_width (GTK_CONTAINER (table), 5);
889 GtkWidget* label = gtk_label_new ("Brush");
890 gtk_widget_show (label);
891 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 0, 1,
892 (GtkAttachOptions) (GTK_FILL),
893 (GtkAttachOptions) (0), 0, 0);
896 GtkWidget* label = gtk_label_new ("Patch");
897 gtk_widget_show (label);
898 gtk_table_attach(GTK_TABLE(table), label, 0, 1, 2, 3,
899 (GtkAttachOptions) (GTK_FILL),
900 (GtkAttachOptions) (0), 0, 0);
903 GtkWidget* label = gtk_label_new ("Width");
904 gtk_widget_show (label);
905 gtk_table_attach(GTK_TABLE(table), label, 2, 3, 0, 1,
906 (GtkAttachOptions) (GTK_FILL),
907 (GtkAttachOptions) (0), 0, 0);
910 GtkWidget* label = gtk_label_new ("Height");
911 gtk_widget_show (label);
912 gtk_table_attach(GTK_TABLE(table), label, 3, 4, 0, 1,
913 (GtkAttachOptions) (GTK_FILL),
914 (GtkAttachOptions) (0), 0, 0);
917 GtkWidget* button = gtk_button_new_with_label ("Axial");
918 gtk_widget_show (button);
919 gtk_table_attach(GTK_TABLE(table), button, 0, 1, 1, 2,
920 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
921 (GtkAttachOptions) (0), 0, 0);
922 g_signal_connect(G_OBJECT(button), "clicked",
923 G_CALLBACK(OnBtnAxial), 0);
924 gtk_widget_set_usize (button, 60, -2);
927 GtkWidget* button = gtk_button_new_with_label ("Fit");
928 gtk_widget_show (button);
929 gtk_table_attach(GTK_TABLE(table), button, 1, 2, 1, 2,
930 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
931 (GtkAttachOptions) (0), 0, 0);
932 g_signal_connect(G_OBJECT(button), "clicked",
933 G_CALLBACK(OnBtnFaceFit), 0);
934 gtk_widget_set_usize (button, 60, -2);
937 GtkWidget* button = gtk_button_new_with_label ("CAP");
938 gtk_widget_show (button);
939 gtk_table_attach(GTK_TABLE(table), button, 0, 1, 3, 4,
940 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
941 (GtkAttachOptions) (0), 0, 0);
942 g_signal_connect(G_OBJECT(button), "clicked",
943 G_CALLBACK(OnBtnPatchdetails), 0);
944 gtk_widget_set_usize (button, 60, -2);
947 GtkWidget* button = gtk_button_new_with_label ("Set...");
948 gtk_widget_show (button);
949 gtk_table_attach(GTK_TABLE(table), button, 1, 2, 3, 4,
950 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
951 (GtkAttachOptions) (0), 0, 0);
952 g_signal_connect(G_OBJECT(button), "clicked",
953 G_CALLBACK(OnBtnPatchreset), 0);
954 gtk_widget_set_usize (button, 60, -2);
957 GtkWidget* button = gtk_button_new_with_label ("Natural");
958 gtk_widget_show (button);
959 gtk_table_attach(GTK_TABLE(table), button, 2, 3, 3, 4,
960 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
961 (GtkAttachOptions) (0), 0, 0);
962 g_signal_connect(G_OBJECT(button), "clicked",
963 G_CALLBACK(OnBtnPatchnatural), 0);
964 gtk_widget_set_usize (button, 60, -2);
967 GtkWidget* button = gtk_button_new_with_label ("Fit");
968 gtk_widget_show (button);
969 gtk_table_attach(GTK_TABLE(table), button, 3, 4, 3, 4,
970 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
971 (GtkAttachOptions) (0), 0, 0);
972 g_signal_connect(G_OBJECT(button), "clicked",
973 G_CALLBACK(OnBtnPatchFit), 0);
974 gtk_widget_set_usize (button, 60, -2);
977 GtkWidget* spin = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1 << 16, 1, 10, 10)), 0, 6);
978 gtk_widget_show (spin);
979 gtk_table_attach(GTK_TABLE(table), spin, 2, 3, 1, 2,
980 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
981 (GtkAttachOptions) (0), 0, 0);
982 gtk_widget_set_usize (spin, 60, -2);
983 AddDialogData(*GTK_SPIN_BUTTON(spin), m_fitHorizontal);
986 GtkWidget* spin = gtk_spin_button_new (GTK_ADJUSTMENT (gtk_adjustment_new (1, 0, 1 << 16, 1, 10, 10)), 0, 6);
987 gtk_widget_show (spin);
988 gtk_table_attach(GTK_TABLE(table), spin, 3, 4, 1, 2,
989 (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
990 (GtkAttachOptions) (0), 0, 0);
991 gtk_widget_set_usize (spin, 60, -2);
992 AddDialogData(*GTK_SPIN_BUTTON(spin), m_fitVertical);
996 if(!string_empty(g_pGameDescription->getKeyValue("si_flags")))
999 GtkFrame* frame = GTK_FRAME(gtk_frame_new("Surface Flags"));
1000 gtk_widget_show(GTK_WIDGET(frame));
1001 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(frame), TRUE, TRUE, 0);
1003 GtkVBox* vbox3 = GTK_VBOX(gtk_vbox_new(FALSE, 4));
1004 //gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
1005 gtk_widget_show(GTK_WIDGET(vbox3));
1006 gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(vbox3));
1008 GtkTable* table = GTK_TABLE(gtk_table_new(8, 4, FALSE));
1009 gtk_widget_show(GTK_WIDGET(table));
1010 gtk_box_pack_start(GTK_BOX(vbox3), GTK_WIDGET(table), TRUE, TRUE, 0);
1011 gtk_table_set_row_spacings(table, 0);
1012 gtk_table_set_col_spacings(table, 0);
1014 GtkCheckButton** p = m_surfaceFlags;
1016 for(int c = 0; c != 4; ++c)
1018 for(int r = 0; r != 8; ++r)
1020 GtkCheckButton* check = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(getSurfaceFlagName(c * 8 + r)));
1021 gtk_widget_show(GTK_WIDGET(check));
1022 gtk_table_attach(table, GTK_WIDGET(check), c, c+1, r, r+1,
1023 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
1024 (GtkAttachOptions)(0), 0, 0);
1026 guint handler_id = togglebutton_connect_toggled(GTK_TOGGLE_BUTTON(check), ApplyFlagsCaller(*this));
1027 g_object_set_data(G_OBJECT(check), "handler", gint_to_pointer(handler_id));
1034 GtkFrame* frame = GTK_FRAME(gtk_frame_new("Content Flags"));
1035 gtk_widget_show(GTK_WIDGET(frame));
1036 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(frame), TRUE, TRUE, 0);
1038 GtkVBox* vbox3 = GTK_VBOX(gtk_vbox_new(FALSE, 4));
1039 //gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
1040 gtk_widget_show(GTK_WIDGET(vbox3));
1041 gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(vbox3));
1044 GtkTable* table = GTK_TABLE(gtk_table_new(8, 4, FALSE));
1045 gtk_widget_show(GTK_WIDGET(table));
1046 gtk_box_pack_start(GTK_BOX(vbox3), GTK_WIDGET(table), TRUE, TRUE, 0);
1047 gtk_table_set_row_spacings(table, 0);
1048 gtk_table_set_col_spacings(table, 0);
1050 GtkCheckButton** p = m_contentFlags;
1052 for(int c = 0; c != 4; ++c)
1054 for(int r = 0; r != 8; ++r)
1056 GtkCheckButton* check = GTK_CHECK_BUTTON(gtk_check_button_new_with_label(getContentFlagName(c * 8 + r)));
1057 gtk_widget_show(GTK_WIDGET(check));
1058 gtk_table_attach(table, GTK_WIDGET(check), c, c+1, r, r+1,
1059 (GtkAttachOptions)(GTK_EXPAND | GTK_FILL),
1060 (GtkAttachOptions)(0), 0, 0);
1062 guint handler_id = togglebutton_connect_toggled(GTK_TOGGLE_BUTTON(check), ApplyFlagsCaller(*this));
1063 g_object_set_data(G_OBJECT(check), "handler", gint_to_pointer(handler_id));
1067 // not allowed to modify detail flag using Surface Inspector
1068 gtk_widget_set_sensitive(GTK_WIDGET(m_contentFlags[BRUSH_DETAIL_FLAG]), FALSE);
1073 GtkFrame* frame = GTK_FRAME(gtk_frame_new("Value"));
1074 gtk_widget_show(GTK_WIDGET(frame));
1075 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(frame), TRUE, TRUE, 0);
1077 GtkVBox* vbox3 = GTK_VBOX(gtk_vbox_new(FALSE, 4));
1078 gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
1079 gtk_widget_show(GTK_WIDGET(vbox3));
1080 gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(vbox3));
1083 GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
1084 gtk_widget_show(GTK_WIDGET(entry));
1085 gtk_box_pack_start(GTK_BOX(vbox3), GTK_WIDGET(entry), TRUE, TRUE, 0);
1086 m_valueEntryWidget = entry;
1087 m_valueEntry.connect(entry);
1094 if(g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES)
1095 // Shamus: Textool goodies...
1097 GtkWidget * frame = gtk_frame_new("Textool");
1098 gtk_widget_show(frame);
1099 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(frame), FALSE, FALSE, 0);
1101 //Prolly should make this a member or global var, so the SI can draw on it...
1102 TexTool::g_textoolWin = glwidget_new(FALSE);
1103 // --> Dunno, but this stuff may be necessary... (Looks like it!)
1104 gtk_widget_ref(TexTool::g_textoolWin);
1105 gtk_widget_set_events(TexTool::g_textoolWin, GDK_DESTROY | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK);
1106 GTK_WIDGET_SET_FLAGS(TexTool::g_textoolWin, GTK_CAN_FOCUS);
1108 gtk_widget_show(TexTool::g_textoolWin);
1109 gtk_widget_set_usize(TexTool::g_textoolWin, -1, 240); //Yeah!
1110 gtk_container_add(GTK_CONTAINER(frame), TexTool::g_textoolWin);
1112 g_signal_connect(G_OBJECT(TexTool::g_textoolWin), "size_allocate", G_CALLBACK(TexTool::size_allocate), NULL);
1113 g_signal_connect(G_OBJECT(TexTool::g_textoolWin), "expose_event", G_CALLBACK(TexTool::expose), NULL);
1114 g_signal_connect(G_OBJECT(TexTool::g_textoolWin), "button_press_event", G_CALLBACK(TexTool::button_press), NULL);
1115 g_signal_connect(G_OBJECT(TexTool::g_textoolWin), "button_release_event", G_CALLBACK(TexTool::button_release), NULL);
1116 g_signal_connect(G_OBJECT(TexTool::g_textoolWin), "motion_notify_event", G_CALLBACK(TexTool::motion), NULL);
1119 GtkWidget * hbox = gtk_hbox_new(FALSE, 5);
1120 gtk_widget_show(hbox);
1121 gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(hbox), FALSE, FALSE, 0);
1122 // Checkboxes go here... (Flip X/Y)
1123 GtkWidget * flipX = gtk_check_button_new_with_label("Flip X axis");
1124 GtkWidget * flipY = gtk_check_button_new_with_label("Flip Y axis");
1125 gtk_widget_show(flipX);
1126 gtk_widget_show(flipY);
1127 gtk_box_pack_start(GTK_BOX(hbox), flipX, FALSE, FALSE, 0);
1128 gtk_box_pack_start(GTK_BOX(hbox), flipY, FALSE, FALSE, 0);
1130 //Instead of this, we probably need to create a vbox to put into the frame, then the
1131 //window, then the hbox. !!! FIX !!!
1132 // gtk_container_add(GTK_CONTAINER(frame), hbox);
1134 //Hmm. Do we really need g_object_set_data? Mebbe not... And we don't! :-)
1135 // g_object_set_data(G_OBJECT(flipX), "handler", gint_to_pointer(g_signal_connect(G_OBJECT(flipX), "toggled", G_CALLBACK(TexTool::flipX), 0)));
1136 // g_object_set_data(G_OBJECT(flipY), "handler", gint_to_pointer(g_signal_connect(G_OBJECT(flipY), "toggled", G_CALLBACK(TexTool::flipY), 0)));
1138 g_signal_connect(G_OBJECT(flipX), "toggled", G_CALLBACK(TexTool::flipX), NULL);
1139 g_signal_connect(G_OBJECT(flipY), "toggled", G_CALLBACK(TexTool::flipY), NULL);
1152 Set the fields to the current texdef (i.e. map/texdef -> dialog widgets)
1153 if faces selected (instead of brushes) -> will read this face texdef, else current texdef
1154 if only patches selected, will read the patch texdef
1158 void spin_button_set_value_no_signal(GtkSpinButton* spin, gdouble value)
1160 guint handler_id = gpointer_to_int(g_object_get_data(G_OBJECT(spin), "handler"));
1161 g_signal_handler_block(G_OBJECT(gtk_spin_button_get_adjustment(spin)), handler_id);
1162 gtk_spin_button_set_value(spin, value);
1163 g_signal_handler_unblock(G_OBJECT(gtk_spin_button_get_adjustment(spin)), handler_id);
1166 void spin_button_set_step_increment(GtkSpinButton* spin, gdouble value)
1168 GtkAdjustment* adjust = gtk_spin_button_get_adjustment(spin);
1169 adjust->step_increment = value;
1172 void SurfaceInspector::Update()
1174 const char * name = SurfaceInspector_GetSelectedShader();
1176 if(shader_is_texture(name))
1178 gtk_entry_set_text(m_texture, shader_get_textureName(name));
1182 gtk_entry_set_text(m_texture, "");
1185 texdef_t shiftScaleRotate;
1186 //Shamus: This is where we get into trouble--the BP code tries to convert to a "faked"
1187 //shift, rotate & scale values from the brush face, which seems to screw up for some reason.
1189 /*globalOutputStream() << "--> SI::Update. About to do ShiftScaleRotate_fromFace()...\n";
1190 SurfaceInspector_GetSelectedBPTexdef();
1191 globalOutputStream() << "BP: (" << g_selectedBrushPrimitTexdef.coords[0][0] << ", " << g_selectedBrushPrimitTexdef.coords[0][1] << ")("
1192 << g_selectedBrushPrimitTexdef.coords[1][0] << ", " << g_selectedBrushPrimitTexdef.coords[1][1] << ")("
1193 << g_selectedBrushPrimitTexdef.coords[0][2] << ", " << g_selectedBrushPrimitTexdef.coords[1][2] << ") SurfaceInspector::Update\n";//*/
1194 //Ok, it's screwed up *before* we get here...
1195 ShiftScaleRotate_fromFace(shiftScaleRotate, SurfaceInspector_GetSelectedTexdef());
1198 spin_button_set_value_no_signal(m_hshiftIncrement.m_spin, shiftScaleRotate.shift[0]);
1199 spin_button_set_step_increment(m_hshiftIncrement.m_spin, g_si_globals.shift[0]);
1200 entry_set_float(m_hshiftIncrement.m_entry, g_si_globals.shift[0]);
1204 spin_button_set_value_no_signal(m_vshiftIncrement.m_spin, shiftScaleRotate.shift[1]);
1205 spin_button_set_step_increment(m_vshiftIncrement.m_spin, g_si_globals.shift[1]);
1206 entry_set_float(m_vshiftIncrement.m_entry, g_si_globals.shift[1]);
1210 spin_button_set_value_no_signal(m_hscaleIncrement.m_spin, shiftScaleRotate.scale[0]);
1211 spin_button_set_step_increment(m_hscaleIncrement.m_spin, g_si_globals.scale[0]);
1212 entry_set_float(m_hscaleIncrement.m_entry, g_si_globals.scale[0]);
1216 spin_button_set_value_no_signal(m_vscaleIncrement.m_spin, shiftScaleRotate.scale[1]);
1217 spin_button_set_step_increment(m_vscaleIncrement.m_spin, g_si_globals.scale[1]);
1218 entry_set_float(m_vscaleIncrement.m_entry, g_si_globals.scale[1]);
1222 spin_button_set_value_no_signal(m_rotateIncrement.m_spin, shiftScaleRotate.rotate);
1223 spin_button_set_step_increment(m_rotateIncrement.m_spin, g_si_globals.rotate);
1224 entry_set_float(m_rotateIncrement.m_entry, g_si_globals.rotate);
1227 if(!string_empty(g_pGameDescription->getKeyValue("si_flags")))
1229 ContentsFlagsValue flags(SurfaceInspector_GetSelectedFlags());
1231 entry_set_int(m_valueEntryWidget, flags.m_value);
1233 for(GtkCheckButton** p = m_surfaceFlags; p != m_surfaceFlags + 32; ++p)
1235 toggle_button_set_active_no_signal(GTK_TOGGLE_BUTTON(*p), flags.m_surfaceFlags & (1 << (p - m_surfaceFlags)));
1238 for(GtkCheckButton** p = m_contentFlags; p != m_contentFlags + 32; ++p)
1240 toggle_button_set_active_no_signal(GTK_TOGGLE_BUTTON(*p), flags.m_contentFlags & (1 << (p - m_contentFlags)));
1249 Reads the fields to get the current texdef (i.e. widgets -> MAP)
1250 in brush primitive mode, grab the fake shift scale rot and compute a new texture matrix
1253 void SurfaceInspector::ApplyShader()
1255 StringOutputStream name(256);
1256 name << GlobalTexturePrefix_get() << gtk_entry_get_text(m_texture);
1258 // TTimo: detect and refuse invalid texture names (at least the ones with spaces)
1259 if(!texdef_name_valid(name.c_str()))
1261 globalErrorStream() << "invalid texture name '" << name.c_str() << "'\n";
1262 SurfaceInspector_queueDraw();
1266 UndoableCommand undo("textureNameSetSelected");
1267 Select_SetShader(name.c_str());
1270 void SurfaceInspector::ApplyTexdef()
1272 texdef_t shiftScaleRotate;
1274 shiftScaleRotate.shift[0] = static_cast<float>(gtk_spin_button_get_value_as_float(m_hshiftIncrement.m_spin));
1275 shiftScaleRotate.shift[1] = static_cast<float>(gtk_spin_button_get_value_as_float(m_vshiftIncrement.m_spin));
1276 shiftScaleRotate.scale[0] = static_cast<float>(gtk_spin_button_get_value_as_float(m_hscaleIncrement.m_spin));
1277 shiftScaleRotate.scale[1] = static_cast<float>(gtk_spin_button_get_value_as_float(m_vscaleIncrement.m_spin));
1278 shiftScaleRotate.rotate = static_cast<float>(gtk_spin_button_get_value_as_float(m_rotateIncrement.m_spin));
1280 TextureProjection projection;
1281 //Shamus: This is the other place that screws up, it seems, since it doesn't seem to do the
1282 //conversion from the face (I think) and so bogus values end up in the thing... !!! FIX !!!
1283 //This is actually OK. :-P
1284 ShiftScaleRotate_toFace(shiftScaleRotate, projection);
1286 UndoableCommand undo("textureProjectionSetSelected");
1287 Select_SetTexdef(projection);
1290 void SurfaceInspector::ApplyFlags()
1292 unsigned int surfaceflags = 0;
1293 for(GtkCheckButton** p = m_surfaceFlags; p != m_surfaceFlags + 32; ++p)
1295 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(*p)))
1297 surfaceflags |= (1 << (p - m_surfaceFlags));
1301 unsigned int contentflags = 0;
1302 for(GtkCheckButton** p = m_contentFlags; p != m_contentFlags + 32; ++p)
1304 if(gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(*p)))
1306 contentflags |= (1 << (p - m_contentFlags));
1310 int value = entry_get_int(m_valueEntryWidget);
1312 UndoableCommand undo("flagsSetSelected");
1313 Select_SetFlags(ContentsFlagsValue(surfaceflags, contentflags, value, true));
1317 void Face_getTexture(Face& face, CopiedString& shader, TextureProjection& projection, ContentsFlagsValue& flags)
1319 shader = face.GetShader();
1320 face.GetTexdef(projection);
1321 flags = face.getShader().m_flags;
1323 typedef Function4<Face&, CopiedString&, TextureProjection&, ContentsFlagsValue&, void, Face_getTexture> FaceGetTexture;
1325 void Face_setTexture(Face& face, const char* shader, const TextureProjection& projection, const ContentsFlagsValue& flags)
1327 face.SetShader(shader);
1328 face.SetTexdef(projection);
1329 face.SetFlags(flags);
1331 typedef Function4<Face&, const char*, const TextureProjection&, const ContentsFlagsValue&, void, Face_setTexture> FaceSetTexture;
1334 void Patch_getTexture(Patch& patch, CopiedString& shader, TextureProjection& projection, ContentsFlagsValue& flags)
1336 shader = patch.GetShader();
1337 projection = TextureProjection(texdef_t(), brushprimit_texdef_t(), Vector3(0, 0, 0), Vector3(0, 0, 0));
1338 flags = ContentsFlagsValue(0, 0, 0, false);
1340 typedef Function4<Patch&, CopiedString&, TextureProjection&, ContentsFlagsValue&, void, Patch_getTexture> PatchGetTexture;
1342 void Patch_setTexture(Patch& patch, const char* shader, const TextureProjection& projection, const ContentsFlagsValue& flags)
1344 patch.SetShader(shader);
1346 typedef Function4<Patch&, const char*, const TextureProjection&, const ContentsFlagsValue&, void, Patch_setTexture> PatchSetTexture;
1349 typedef Callback3<CopiedString&, TextureProjection&, ContentsFlagsValue&> GetTextureCallback;
1350 typedef Callback3<const char*, const TextureProjection&, const ContentsFlagsValue&> SetTextureCallback;
1354 GetTextureCallback getTexture;
1355 SetTextureCallback setTexture;
1359 void Face_getClosest(Face& face, SelectionTest& test, SelectionIntersection& bestIntersection, Texturable& texturable)
1361 SelectionIntersection intersection;
1362 face.testSelect(test, intersection);
1363 if(intersection.valid()
1364 && SelectionIntersection_closer(intersection, bestIntersection))
1366 bestIntersection = intersection;
1367 texturable.setTexture = makeCallback3(FaceSetTexture(), face);
1368 texturable.getTexture = makeCallback3(FaceGetTexture(), face);
1373 class OccludeSelector : public Selector
1375 SelectionIntersection& m_bestIntersection;
1378 OccludeSelector(SelectionIntersection& bestIntersection, bool& occluded) : m_bestIntersection(bestIntersection), m_occluded(occluded)
1382 void pushSelectable(Selectable& selectable)
1385 void popSelectable()
1388 void addIntersection(const SelectionIntersection& intersection)
1390 if(SelectionIntersection_closer(intersection, m_bestIntersection))
1392 m_bestIntersection = intersection;
1398 class BrushGetClosestFaceVisibleWalker : public scene::Graph::Walker
1400 SelectionTest& m_test;
1401 Texturable& m_texturable;
1402 mutable SelectionIntersection m_bestIntersection;
1404 BrushGetClosestFaceVisibleWalker(SelectionTest& test, Texturable& texturable) : m_test(test), m_texturable(texturable)
1407 bool pre(const scene::Path& path, scene::Instance& instance) const
1409 if(path.top().get().visible())
1411 BrushInstance* brush = Instance_getBrush(instance);
1414 m_test.BeginMesh(brush->localToWorld());
1416 for(Brush::const_iterator i = brush->getBrush().begin(); i != brush->getBrush().end(); ++i)
1418 Face_getClosest(*(*i), m_test, m_bestIntersection, m_texturable);
1423 SelectionTestable* selectionTestable = Instance_getSelectionTestable(instance);
1424 if(selectionTestable)
1427 OccludeSelector selector(m_bestIntersection, occluded);
1428 selectionTestable->testSelect(selector, m_test);
1431 Patch* patch = Node_getPatch(path.top());
1434 m_texturable.setTexture = makeCallback3(PatchSetTexture(), *patch);
1435 m_texturable.getTexture = makeCallback3(PatchGetTexture(), *patch);
1439 m_texturable = Texturable();
1449 Texturable Scene_getClosestTexturable(scene::Graph& graph, SelectionTest& test)
1451 Texturable texturable;
1452 graph.traverse(BrushGetClosestFaceVisibleWalker(test, texturable));
1456 bool Scene_getClosestTexture(scene::Graph& graph, SelectionTest& test, CopiedString& shader, TextureProjection& projection, ContentsFlagsValue& flags)
1458 Texturable texturable = Scene_getClosestTexturable(graph, test);
1459 if(texturable.getTexture != GetTextureCallback())
1461 texturable.getTexture(shader, projection, flags);
1467 void Scene_setClosestTexture(scene::Graph& graph, SelectionTest& test, const char* shader, const TextureProjection& projection, const ContentsFlagsValue& flags)
1469 Texturable texturable = Scene_getClosestTexturable(graph, test);
1470 if(texturable.setTexture != SetTextureCallback())
1472 texturable.setTexture(shader, projection, flags);
1480 TextureProjection m_projection;
1481 ContentsFlagsValue m_flags;
1484 FaceTexture g_faceTextureClipboard;
1486 void FaceTextureClipboard_setDefault()
1488 g_faceTextureClipboard.m_flags = ContentsFlagsValue(0, 0, 0, false);
1489 TexDef_Construct_Default(g_faceTextureClipboard.m_projection);
1492 void TextureClipboard_textureSelected(const char* shader)
1494 FaceTextureClipboard_setDefault();
1497 class TextureBrowser;
1498 extern TextureBrowser g_TextureBrowser;
1499 void TextureBrowser_SetSelectedShader(TextureBrowser& textureBrowser, const char* shader);
1500 const char* TextureBrowser_GetSelectedShader(TextureBrowser& textureBrowser);
1502 void Scene_copyClosestTexture(SelectionTest& test)
1504 CopiedString shader;
1505 if(Scene_getClosestTexture(GlobalSceneGraph(), test, shader, g_faceTextureClipboard.m_projection, g_faceTextureClipboard.m_flags))
1507 TextureBrowser_SetSelectedShader(g_TextureBrowser, shader.c_str());
1511 void Scene_applyClosestTexture(SelectionTest& test)
1513 UndoableCommand command("facePaintTexture");
1515 Scene_setClosestTexture(GlobalSceneGraph(), test, TextureBrowser_GetSelectedShader(g_TextureBrowser), g_faceTextureClipboard.m_projection, g_faceTextureClipboard.m_flags);
1517 SceneChangeNotify();
1524 void SelectedFaces_copyTexture()
1526 if(!g_SelectedFaceInstances.empty())
1528 Face& face = g_SelectedFaceInstances.last().getFace();
1529 face.GetTexdef(g_faceTextureClipboard.m_projection);
1530 g_faceTextureClipboard.m_flags = face.getShader().m_flags;
1532 TextureBrowser_SetSelectedShader(g_TextureBrowser, face.getShader().getShader());
1536 void FaceInstance_pasteTexture(FaceInstance& faceInstance)
1538 faceInstance.getFace().SetTexdef(g_faceTextureClipboard.m_projection);
1539 faceInstance.getFace().SetShader(TextureBrowser_GetSelectedShader(g_TextureBrowser));
1540 faceInstance.getFace().SetFlags(g_faceTextureClipboard.m_flags);
1541 SceneChangeNotify();
1544 bool SelectedFaces_empty()
1546 return g_SelectedFaceInstances.empty();
1549 void SelectedFaces_pasteTexture()
1551 UndoableCommand command("facePasteTexture");
1552 g_SelectedFaceInstances.foreach(FaceInstance_pasteTexture);
1557 void SurfaceInspector_constructPreferences(PreferencesPage& page)
1559 page.appendCheckBox("", "Surface Inspector Increments Match Grid", g_si_globals.m_bSnapTToGrid);
1561 void SurfaceInspector_constructPage(PreferenceGroup& group)
1563 PreferencesPage page(group.createPage("Surface Inspector", "Surface Inspector Preferences"));
1564 SurfaceInspector_constructPreferences(page);
1566 void SurfaceInspector_registerPreferencesPage()
1568 PreferencesDialog_addSettingsPage(FreeCaller1<PreferenceGroup&, SurfaceInspector_constructPage>());
1571 void SurfaceInspector_registerCommands()
1573 GlobalCommands_insert("FitTexture", FreeCaller<SurfaceInspector_FitTexture>(), Accelerator('B', (GdkModifierType)GDK_SHIFT_MASK));
1574 GlobalCommands_insert("SurfaceInspector", FreeCaller<SurfaceInspector_toggleShown>(), Accelerator('S'));
1576 GlobalCommands_insert("FaceCopyTexture", FreeCaller<SelectedFaces_copyTexture>());
1577 GlobalCommands_insert("FacePasteTexture", FreeCaller<SelectedFaces_pasteTexture>());
1581 #include "preferencesystem.h"
1584 void SurfaceInspector_Construct()
1586 g_SurfaceInspector = new SurfaceInspector;
1588 SurfaceInspector_registerCommands();
1590 FaceTextureClipboard_setDefault();
1592 GlobalPreferenceSystem().registerPreference("SurfaceWnd", getSurfaceInspector().m_importPosition, getSurfaceInspector().m_exportPosition);
1593 GlobalPreferenceSystem().registerPreference("SI_SurfaceTexdef_Scale1", FloatImportStringCaller(g_si_globals.scale[0]), FloatExportStringCaller(g_si_globals.scale[0]));
1594 GlobalPreferenceSystem().registerPreference("SI_SurfaceTexdef_Scale2", FloatImportStringCaller(g_si_globals.scale[1]), FloatExportStringCaller(g_si_globals.scale[1]));
1595 GlobalPreferenceSystem().registerPreference("SI_SurfaceTexdef_Shift1", FloatImportStringCaller(g_si_globals.shift[0]), FloatExportStringCaller(g_si_globals.shift[0]));
1596 GlobalPreferenceSystem().registerPreference("SI_SurfaceTexdef_Shift2", FloatImportStringCaller(g_si_globals.shift[1]), FloatExportStringCaller(g_si_globals.shift[1]));
1597 GlobalPreferenceSystem().registerPreference("SI_SurfaceTexdef_Rotate", FloatImportStringCaller(g_si_globals.rotate), FloatExportStringCaller(g_si_globals.rotate));
1598 GlobalPreferenceSystem().registerPreference("SnapTToGrid", BoolImportStringCaller(g_si_globals.m_bSnapTToGrid), BoolExportStringCaller(g_si_globals.m_bSnapTToGrid));
1600 typedef FreeCaller1<const Selectable&, SurfaceInspector_SelectionChanged> SurfaceInspectorSelectionChangedCaller;
1601 GlobalSelectionSystem().addSelectionChangeCallback(SurfaceInspectorSelectionChangedCaller());
1602 typedef FreeCaller<SurfaceInspector_updateSelection> SurfaceInspectorUpdateSelectionCaller;
1603 Brush_addTextureChangedCallback(SurfaceInspectorUpdateSelectionCaller());
1604 Patch_addTextureChangedCallback(SurfaceInspectorUpdateSelectionCaller());
1606 SurfaceInspector_registerPreferencesPage();
1608 void SurfaceInspector_Destroy()
1610 delete g_SurfaceInspector;
1617 namespace TexTool { // namespace hides these symbols from other object-files
1619 //Shamus: Textool functions, including GTK+ callbacks
1622 //NOTE: Black screen when TT first comes up is caused by an uninitialized Extent... !!! FIX !!!
1623 // But... You can see down below that it *is* initialized! WTF?
1626 float minX, minY, maxX, maxY;
1627 float width(void) { return fabs(maxX - minX); }
1628 float height(void) { return fabs(maxY - minY); }
1631 //This seems to control the texture scale... (Yep! ;-)
1632 Extent extents = { -2.0f, -2.0f, +2.0f, +2.0f };
1633 brushprimit_texdef_t tm; // Texture transform matrix
1634 Vector2 pts[c_brush_maxFaces];
1638 Vector2 textureSize;
1640 #define VP_PADDING 1.2
1641 #define PI 3.14159265358979
1642 bool lButtonDown = false;
1643 bool rButtonDown = false;
1646 bool haveAnchor = false;
1647 brushprimit_texdef_t currentBP;
1648 brushprimit_texdef_t origBP; // Original brush primitive (before we muck it up)
1649 float controlRadius = 5.0f;
1650 float rotationAngle = 0.0f;
1651 float rotationAngle2 = 0.0f;
1652 float oldRotationAngle;
1653 Vector2 rotationPoint;
1654 bool translatingX = false; // Widget state variables
1655 bool translatingY = false;
1656 bool scalingX = false;
1657 bool scalingY = false;
1658 bool rotating = false;
1659 bool resizingX = false; // Not sure what this means... :-/
1660 bool resizingY = false;
1661 float origAngle, origScaleX, origScaleY;
1665 // Function prototypes (move up to top later...)
1667 void DrawCircularArc(Vector2 ctr, float startAngle, float endAngle, float radius);
1670 void CopyPointsFromSelectedFace(void)
1672 // Make sure that there's a face and winding to get!
1674 if (g_SelectedFaceInstances.empty())
1680 Face & face = g_SelectedFaceInstances.last().getFace();
1681 textureNum = face.getShader().m_state->getTexture().texture_number;
1682 textureSize.x() = face.getShader().m_state->getTexture().width;
1683 textureSize.y() = face.getShader().m_state->getTexture().height;
1684 //globalOutputStream() << "--> Texture #" << textureNum << ": " << textureSize.x() << " x " << textureSize.y() << "...\n";
1686 currentBP = SurfaceInspector_GetSelectedTexdef().m_brushprimit_texdef;
1688 face.EmitTextureCoordinates();
1689 Winding & w = face.getWinding();
1692 for(Winding::const_iterator i=w.begin(); i!=w.end(); i++)
1694 //globalOutputStream() << (*i).texcoord.x() << " " << (*i).texcoord.y() << ", ";
1695 pts[count].x() = (*i).texcoord.x();
1696 pts[count].y() = (*i).texcoord.y();
1702 //globalOutputStream() << " ..copied points\n";
1705 brushprimit_texdef_t bp;
1706 //This approach is probably wrongheaded and just not right anyway. So, !!! FIX !!! [DONE]
1707 void CommitChanges(void)
1709 texdef_t t; // Throwaway, since this is BP only
1711 bp.coords[0][0] = tm.coords[0][0] * origBP.coords[0][0] + tm.coords[0][1] * origBP.coords[1][0];
1712 bp.coords[0][1] = tm.coords[0][0] * origBP.coords[0][1] + tm.coords[0][1] * origBP.coords[1][1];
1713 bp.coords[0][2] = tm.coords[0][0] * origBP.coords[0][2] + tm.coords[0][1] * origBP.coords[1][2] + tm.coords[0][2];
1714 //Ok, this works for translation...
1715 // bp.coords[0][2] = tm.coords[0][0] * origBP.coords[0][2] + tm.coords[0][1] * origBP.coords[1][2] + tm.coords[0][2] * textureSize.x();
1716 bp.coords[1][0] = tm.coords[1][0] * origBP.coords[0][0] + tm.coords[1][1] * origBP.coords[1][0];
1717 bp.coords[1][1] = tm.coords[1][0] * origBP.coords[0][1] + tm.coords[1][1] * origBP.coords[1][1];
1718 bp.coords[1][2] = tm.coords[1][0] * origBP.coords[0][2] + tm.coords[1][1] * origBP.coords[1][2] + tm.coords[1][2];
1719 // bp.coords[1][2] = tm.coords[1][0] * origBP.coords[0][2] + tm.coords[1][1] * origBP.coords[1][2] + tm.coords[1][2] * textureSize.y();
1721 //This doesn't work: g_brush_texture_changed();
1723 //Note: We should only set an undo *after* the button has been released... !!! FIX !!!
1724 //Definitely *should* have an undo, though!
1725 // UndoableCommand undo("textureProjectionSetSelected");
1726 Select_SetTexdef(TextureProjection(t, bp, Vector3(0, 0, 0), Vector3(0, 0, 0)));
1727 //This is working, but for some reason the translate is causing the rest of the SI
1728 //widgets to yield bad readings... !!! FIX !!!
1729 //I.e., click on textool window, translate face wireframe, then controls go crazy. Dunno why.
1730 //It's because there were some uncommented out add/removeScale functions in brush.h and a
1731 //removeScale in brushmanip.cpp... :-/
1732 //Translate isn't working at all now... :-(
1733 //It's because we need to multiply in some scaling factor (prolly the texture width/height)
1737 void UpdateControlPoints(void)
1741 // Init texture transform matrix
1743 tm.coords[0][0] = 1.0f; tm.coords[0][1] = 0.0f; tm.coords[0][2] = 0.0f;
1744 tm.coords[1][0] = 0.0f; tm.coords[1][1] = 1.0f; tm.coords[1][2] = 0.0f;
1749 For shifting we have:
1752 The code that should provide reasonable defaults, but doesn't for some reason:
1753 It's scaling the BP by 128 for some reason, between the time it's created and the
1754 time we get back to the SI widgets:
1756 static void OnBtnAxial(GtkWidget *widget, gpointer data)
1758 UndoableCommand undo("textureDefault");
1759 TextureProjection projection;
1760 TexDef_Construct_Default(projection);
1761 Select_SetTexdef(projection);
1764 Select_SetTexdef() calls Scene_BrushSetTexdef_Component_Selected(GlobalSceneGraph(), projection)
1765 which is in brushmanip.h: This eventually calls
1766 Texdef_Assign(m_texdef, texdef, m_brushprimit_texdef, brushprimit_texdef) in class Face...
1767 which just copies from brushpr to m_brushpr...
1770 //Small problem with this thing: It's scaled to the texture which is all screwed up... !!! FIX !!! [DONE]
1771 //Prolly should separate out the grid drawing so that we can draw it behind the polygon.
1772 const float gridWidth = 1.3f;// Let's try an absolute height... WORKS!!!
1773 // NOTE that 2.0 is the height of the viewport. Dunno why... Should make collision
1774 // detection easier...
1775 const float gridRadius = gridWidth * 0.5f;
1777 typedef const float WidgetColor[3];
1778 const WidgetColor widgetColor[10] = {
1779 { 1.0000f, 0.2000f, 0.0000f }, // Red
1780 { 0.9137f, 0.9765f, 0.4980f }, // Yellow
1781 { 0.0000f, 0.6000f, 0.3216f }, // Green
1782 { 0.6157f, 0.7726f, 0.8196f }, // Cyan
1783 { 0.4980f, 0.5000f, 0.4716f }, // Grey
1786 { 1.0000f, 0.6000f, 0.4000f }, // Light Red
1787 { 1.0000f, 1.0000f, 0.8980f }, // Light Yellow
1788 { 0.4000f, 1.0000f, 0.7216f }, // Light Green
1789 { 1.0000f, 1.0000f, 1.0000f }, // Light Cyan
1790 { 0.8980f, 0.9000f, 0.8716f } // Light Grey
1794 #define COLOR_YELLOW 1
1795 #define COLOR_GREEN 2
1796 #define COLOR_CYAN 3
1797 #define COLOR_GREY 4
1798 #define COLOR_LT_RED 5
1799 #define COLOR_LT_YELLOW 6
1800 #define COLOR_LT_GREEN 7
1801 #define COLOR_LT_CYAN 8
1802 #define COLOR_LT_GREY 9
1804 void DrawControlWidgets(void)
1806 //Note that the grid should go *behind* the face outline... !!! FIX !!!
1808 float xStart = center.x() - (gridWidth / 2.0f);
1809 float yStart = center.y() - (gridWidth / 2.0f);
1810 float xScale = (extents.height() / extents.width()) * (textureSize.y() / textureSize.x());
1813 //Small problem with this approach: Changing the center point in the TX code doesn't seem to
1814 //change anything here--prolly because we load a new identity matrix. A couple of ways to fix
1815 //this would be to get rid of that code, or change the center to a new point by taking into
1816 //account the transforms that we toss with the new identity matrix. Dunno which is better.
1818 glScalef(xScale, 1.0, 1.0); // Will that square it up? Yup.
1819 glRotatef(static_cast<float>(radians_to_degrees(atan2(-currentBP.coords[0][1], currentBP.coords[0][0]))), 0.0, 0.0, -1.0);
1820 glTranslatef(-center.x(), -center.y(), 0.0);
1823 glColor3fv(translatingX && translatingY ? widgetColor[COLOR_LT_YELLOW] : widgetColor[COLOR_YELLOW]);
1824 glBegin(GL_LINE_LOOP);
1825 DrawCircularArc(center, 0, 2.0f * PI, gridRadius * 0.16);
1831 glColor3fv(translatingY && !translatingX ? widgetColor[COLOR_LT_GREEN] : widgetColor[COLOR_GREEN]);
1832 glVertex2f(center.x(), center.y() + (gridRadius * 0.16));
1833 glVertex2f(center.x(), center.y() + (gridRadius * 1.00));
1834 glColor3fv(translatingX && !translatingY ? widgetColor[COLOR_LT_RED] : widgetColor[COLOR_RED]);
1835 glVertex2f(center.x() + (gridRadius * 0.16), center.y());
1836 glVertex2f(center.x() + (gridRadius * 1.00), center.y());
1840 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1841 glBegin(GL_TRIANGLES);
1842 glColor3fv(translatingY && !translatingX ? widgetColor[COLOR_LT_GREEN] : widgetColor[COLOR_GREEN]);
1843 glVertex2f(center.x(), center.y() + (gridRadius * 1.10));
1844 glVertex2f(center.x() + (gridRadius * 0.06), center.y() + (gridRadius * 0.94));
1845 glVertex2f(center.x() - (gridRadius * 0.06), center.y() + (gridRadius * 0.94));
1846 glColor3fv(translatingX && !translatingY ? widgetColor[COLOR_LT_RED] : widgetColor[COLOR_RED]);
1847 glVertex2f(center.x() + (gridRadius * 1.10), center.y());
1848 glVertex2f(center.x() + (gridRadius * 0.94), center.y() + (gridRadius * 0.06));
1849 glVertex2f(center.x() + (gridRadius * 0.94), center.y() - (gridRadius * 0.06));
1853 glBegin(GL_LINE_STRIP);
1854 glColor3fv(rotating ? widgetColor[COLOR_LT_CYAN] : widgetColor[COLOR_CYAN]);
1855 DrawCircularArc(center, 0.03f * PI, 0.47f * PI, gridRadius * 0.90);
1859 glColor3fv(scalingY && !scalingX ? widgetColor[COLOR_LT_GREEN] : widgetColor[COLOR_GREEN]);
1861 glVertex2f(center.x() + (gridRadius * 0.20), center.y() + (gridRadius * 1.50));
1862 glVertex2f(center.x() - (gridRadius * 0.20), center.y() + (gridRadius * 1.50));
1864 glBegin(GL_LINE_LOOP);
1865 glVertex2f(center.x() + (gridRadius * 0.10), center.y() + (gridRadius * 1.40));
1866 glVertex2f(center.x() - (gridRadius * 0.10), center.y() + (gridRadius * 1.40));
1867 glVertex2f(center.x() - (gridRadius * 0.10), center.y() + (gridRadius * 1.20));
1868 glVertex2f(center.x() + (gridRadius * 0.10), center.y() + (gridRadius * 1.20));
1871 glColor3fv(scalingX && !scalingY ? widgetColor[COLOR_LT_RED] : widgetColor[COLOR_RED]);
1873 glVertex2f(center.x() + (gridRadius * 1.50), center.y() + (gridRadius * 0.20));
1874 glVertex2f(center.x() + (gridRadius * 1.50), center.y() - (gridRadius * 0.20));
1876 glBegin(GL_LINE_LOOP);
1877 glVertex2f(center.x() + (gridRadius * 1.40), center.y() + (gridRadius * 0.10));
1878 glVertex2f(center.x() + (gridRadius * 1.40), center.y() - (gridRadius * 0.10));
1879 glVertex2f(center.x() + (gridRadius * 1.20), center.y() - (gridRadius * 0.10));
1880 glVertex2f(center.x() + (gridRadius * 1.20), center.y() + (gridRadius * 0.10));
1883 glColor3fv(scalingX && scalingY ? widgetColor[COLOR_LT_CYAN] : widgetColor[COLOR_CYAN]);
1884 glBegin(GL_LINE_STRIP);
1885 glVertex2f(center.x() + (gridRadius * 1.50), center.y() + (gridRadius * 1.10));
1886 glVertex2f(center.x() + (gridRadius * 1.50), center.y() + (gridRadius * 1.50));
1887 glVertex2f(center.x() + (gridRadius * 1.10), center.y() + (gridRadius * 1.50));
1889 glBegin(GL_LINE_LOOP);
1890 glVertex2f(center.x() + (gridRadius * 1.40), center.y() + (gridRadius * 1.40));
1891 glVertex2f(center.x() + (gridRadius * 1.40), center.y() + (gridRadius * 1.20));
1892 glVertex2f(center.x() + (gridRadius * 1.20), center.y() + (gridRadius * 1.20));
1893 glVertex2f(center.x() + (gridRadius * 1.20), center.y() + (gridRadius * 1.40));
1899 void DrawControlPoints(void)
1902 glBegin(GL_LINE_LOOP);
1904 for(int i=0; i<numPts; i++)
1905 glVertex2f(pts[i].x(), pts[i].y());
1910 // Note: Setup and all that jazz must be done by the caller!
1912 void DrawCircularArc(Vector2 ctr, float startAngle, float endAngle, float radius)
1914 float stepSize = (2.0f * PI) / 200.0f;
1916 for(float angle=startAngle; angle<=endAngle; angle+=stepSize)
1917 glVertex2f(ctr.x() + radius * cos(angle), ctr.y() + radius * sin(angle));
1926 // Find selected texture's extents...
1928 extents.minX = extents.maxX = pts[0].x(),
1929 extents.minY = extents.maxY = pts[0].y();
1931 for(int i=1; i<numPts; i++)
1933 if (pts[i].x() < extents.minX)
1934 extents.minX = pts[i].x();
1935 if (pts[i].x() > extents.maxX)
1936 extents.maxX = pts[i].x();
1937 if (pts[i].y() < extents.minY)
1938 extents.minY = pts[i].y();
1939 if (pts[i].y() > extents.maxY)
1940 extents.maxY = pts[i].y();
1943 // Do some viewport fitting stuff...
1945 //globalOutputStream() << "--> Center: " << center.x() << ", " << center.y() << "\n";
1946 //globalOutputStream() << "--> Extents (stage 1): " << extents.minX << ", "
1947 // << extents.maxX << ", " << extents.minY << ", " << extents.maxY << "\n";
1948 // TTimo: Apply a ratio to get the area we'll draw.
1949 center.x() = 0.5f * (extents.minX + extents.maxX),
1950 center.y() = 0.5f * (extents.minY + extents.maxY);
1951 extents.minX = center.x() + VP_PADDING * (extents.minX - center.x()),
1952 extents.minY = center.y() + VP_PADDING * (extents.minY - center.y()),
1953 extents.maxX = center.x() + VP_PADDING * (extents.maxX - center.x()),
1954 extents.maxY = center.y() + VP_PADDING * (extents.maxY - center.y());
1955 //globalOutputStream() << "--> Extents (stage 2): " << extents.minX << ", "
1956 // << extents.maxX << ", " << extents.minY << ", " << extents.maxY << "\n";
1958 // TTimo: We want a texture with the same X / Y ratio.
1959 // TTimo: Compute XY space / window size ratio.
1960 float SSize = extents.width(), TSize = extents.height();
1961 float ratioX = textureSize.x() * extents.width() / windowSize.x(),
1962 ratioY = textureSize.y() * extents.height() / windowSize.y();
1963 //globalOutputStream() << "--> Texture size: " << textureSize.x() << ", " << textureSize.y() << "\n";
1964 //globalOutputStream() << "--> Window size: " << windowSize.x() << ", " << windowSize.y() << "\n";
1966 if (ratioX > ratioY)
1968 TSize = (windowSize.y() * ratioX) / textureSize.y();
1969 // TSize = extents.width() * (windowSize.y() / windowSize.x()) * (textureSize.x() / textureSize.y());
1973 SSize = (windowSize.x() * ratioY) / textureSize.x();
1974 // SSize = extents.height() * (windowSize.x() / windowSize.y()) * (textureSize.y() / textureSize.x());
1977 extents.minX = center.x() - 0.5f * SSize, extents.maxX = center.x() + 0.5f * SSize,
1978 extents.minY = center.y() - 0.5f * TSize, extents.maxY = center.y() + 0.5f * TSize;
1979 //globalOutputStream() << "--> Extents (stage 3): " << extents.minX << ", "
1980 // << extents.maxX << ", " << extents.minY << ", " << extents.maxY << "\n";
1983 gboolean size_allocate(GtkWidget * win, GtkAllocation * a, gpointer)
1985 windowSize.x() = a->width;
1986 windowSize.y() = a->height;
1991 gboolean expose(GtkWidget * win, GdkEventExpose * e, gpointer)
1993 // globalOutputStream() << "--> Textool Window was exposed!\n";
1994 // globalOutputStream() << " (window width/height: " << cc << "/" << e->area.height << ")\n";
1996 // windowSize.x() = e->area.width, windowSize.y() = e->area.height;
1997 //This needs to go elsewhere...
2000 if (glwidget_make_current(win) == FALSE)
2002 globalOutputStream() << " FAILED to make current! Oh, the agony! :-(\n";
2006 CopyPointsFromSelectedFace();
2013 // Probably should init button/anchor states here as well...
2014 // rotationAngle = 0.0f;
2015 glClearColor(0, 0, 0, 0);
2016 glViewport(0, 0, e->area.width, e->area.height);
2017 glMatrixMode(GL_PROJECTION);
2021 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
2022 glDisable(GL_DEPTH_TEST);
2023 glDisable(GL_BLEND);
2025 glOrtho(extents.minX, extents.maxX, extents.maxY, extents.minY, -1, 1);
2028 // draw the texture background
2029 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
2030 glBindTexture(GL_TEXTURE_2D, textureNum);
2032 glEnable(GL_TEXTURE_2D);
2034 glTexCoord2f(extents.minX, extents.minY);
2035 glVertex2f(extents.minX, extents.minY);
2036 glTexCoord2f(extents.maxX, extents.minY);
2037 glVertex2f(extents.maxX, extents.minY);
2038 glTexCoord2f(extents.maxX, extents.maxY);
2039 glVertex2f(extents.maxX, extents.maxY);
2040 glTexCoord2f(extents.minX, extents.maxY);
2041 glVertex2f(extents.minX, extents.maxY);
2043 glDisable(GL_TEXTURE_2D);
2045 // draw the texture-space grid
2046 glColor3fv(widgetColor[COLOR_GREY]);
2049 const int gridSubdivisions = 8;
2050 const float gridExtents = 4.0f;
2052 for(int i = 0; i < gridSubdivisions + 1; ++i)
2054 float y = i * (gridExtents / float(gridSubdivisions));
2055 float x = i * (gridExtents / float(gridSubdivisions));
2057 glVertex2f(gridExtents, y);
2059 glVertex2f(x, gridExtents);
2064 DrawControlPoints();
2065 DrawControlWidgets();
2067 // reset the current texture
2068 // glBindTexture(GL_TEXTURE_2D, 0);
2070 glwidget_swap_buffers(win);
2075 /*int FindSelectedPoint(int x, int y)
2077 for(int i=0; i<numPts; i++)
2079 int nx = (int)(windowSize.x() * (pts[i].x() - extents.minX) / extents.width());
2080 int ny = (int)(windowSize.y() * (pts[i].y() - extents.minY) / extents.height());
2082 if (abs(nx - x) <= 3 && abs(ny - y) <= 3)
2091 Vector2 dragPoint; // Defined in terms of window space (+x/-y)
2093 gboolean button_press(GtkWidget * win, GdkEventButton * e, gpointer)
2095 // globalOutputStream() << "--> Textool button press...\n";
2100 GlobalUndoSystem().start();
2104 //globalOutputStream() << "--> Original BP: [" << origBP.coords[0][0] << "][" << origBP.coords[0][1] << "][" << origBP.coords[0][2] << "]\n";
2105 //globalOutputStream() << " [" << origBP.coords[1][0] << "][" << origBP.coords[1][1] << "][" << origBP.coords[1][2] << "]\n";
2106 //float angle = atan2(origBP.coords[0][1], origBP.coords[0][0]) * 180.0f / 3.141592653589f;
2107 origAngle = (origBP.coords[0][1] > 0 ? PI : -PI); // Could also be -PI... !!! FIX !!! [DONE]
2109 if (origBP.coords[0][0] != 0.0f)
2110 origAngle = atan(origBP.coords[0][1] / origBP.coords[0][0]);
2112 origScaleX = origBP.coords[0][0] / cos(origAngle);
2113 origScaleY = origBP.coords[1][1] / cos(origAngle);
2114 rotationAngle = origAngle;
2115 oldCenter[0] = oldCenter[1] = 0;
2117 //globalOutputStream() << "--> BP stats: ang=" << origAngle * RAD_TO_DEG << ", scale=" << origScaleX << "/" << origScaleY << "\n";
2118 //Should also set the Flip X/Y checkboxes here as well... !!! FIX !!!
2119 //Also: should reverse texture left/right up/down instead of flipping the points...
2122 //float nx = windowSize.x() * (e->x - extents.minX) / (extents.maxX - extents.minX);
2123 //float ny = windowSize.y() * (e->y - extents.minY) / (extents.maxY - extents.minY);
2125 //But I want it to scroll the texture window, not the points... !!! FIX !!!
2126 //Actually, should scroll the texture window only when mouse is down on no widgets...
2127 float nx = e->x / windowSize.x() * extents.width() + extents.minX;
2128 float ny = e->y / windowSize.y() * extents.height() + extents.minY;
2129 trans.x() = -tm.coords[0][0] * nx - tm.coords[0][1] * ny;
2130 trans.y() = -tm.coords[1][0] * nx - tm.coords[1][1] * ny;
2132 dragPoint.x() = e->x, dragPoint.y() = e->y;
2133 trans2.x() = nx, trans2.y() = ny;
2134 oldRotationAngle = rotationAngle;
2135 // oldTrans.x() = tm.coords[0][2] - nx * textureSize.x();
2136 // oldTrans.y() = tm.coords[1][2] - ny * textureSize.y();
2137 oldTrans.x() = tm.coords[0][2];
2138 oldTrans.y() = tm.coords[1][2];
2139 oldCenter.x() = center.x();
2140 oldCenter.y() = center.y();
2146 /* else if (e->button == 3)
2151 //globalOutputStream() << "(" << (haveAnchor ? "anchor" : "released") << ")\n";
2156 gboolean button_release(GtkWidget * win, GdkEventButton * e, gpointer)
2158 // globalOutputStream() << "--> Textool button release...\n";
2162 /* float ptx = e->x / windowSize.x() * extents.width() + extents.minX;
2163 float pty = e->y / windowSize.y() * extents.height() + extents.minY;
2165 //This prolly should go into the mouse move code...
2166 //Doesn't work correctly anyway...
2167 if (translatingX || translatingY)
2168 center.x() = ptx, center.y() = pty;//*/
2170 lButtonDown = false;
2172 if(translatingX || translatingY)
2174 GlobalUndoSystem().finish("translateTexture");
2178 GlobalUndoSystem().finish("rotateTexture");
2180 else if(scalingX || scalingY)
2182 GlobalUndoSystem().finish("scaleTexture");
2184 else if(resizingX || resizingY)
2186 GlobalUndoSystem().finish("resizeTexture");
2190 GlobalUndoSystem().finish("textoolUnknown");
2193 rotating = translatingX = translatingY = scalingX = scalingY
2194 = resizingX = resizingY = false;
2198 else if (e->button == 3)
2200 rButtonDown = false;
2207 void C2DView::GridForWindow( float c[2], int x, int y)
2209 SpaceForWindow( c, x, y );
2212 c[0] /= m_GridStep[0];
2213 c[1] /= m_GridStep[1];
2214 c[0] = (float)floor( c[0] + 0.5f );
2215 c[1] = (float)floor( c[1] + 0.5f );
2216 c[0] *= m_GridStep[0];
2217 c[1] *= m_GridStep[1];
2219 void C2DView::SpaceForWindow( float c[2], int x, int y)
2221 c[0] = ((float)(x))/((float)(m_rect.right-m_rect.left))*(m_Maxs[0]-m_Mins[0])+m_Mins[0];
2222 c[1] = ((float)(y))/((float)(m_rect.bottom-m_rect.top))*(m_Maxs[1]-m_Mins[1])+m_Mins[1];
2225 gboolean motion(GtkWidget * win, GdkEventMotion * e, gpointer)
2227 // globalOutputStream() << "--> Textool motion...\n";
2231 if (translatingX || translatingY)
2233 float ptx = e->x / windowSize.x() * extents.width() + extents.minX;
2234 float pty = e->y / windowSize.y() * extents.height() + extents.minY;
2236 //Need to fix this to take the rotation angle into account, so that it moves along
2237 //the rotated X/Y axis...
2240 // tm.coords[0][2] = (trans.x() + ptx) * textureSize.x();
2241 //This works, but only when the angle is zero. !!! FIX !!! [DONE]
2242 // tm.coords[0][2] = oldCenter.x() + (ptx * textureSize.x());
2243 tm.coords[0][2] = oldTrans.x() + (ptx - trans2.x()) * textureSize.x();
2244 // center.x() = oldCenter.x() + (ptx - trans2.x());
2249 // tm.coords[1][2] = (trans.y() + pty) * textureSize.y();
2250 // tm.coords[1][2] = oldCenter.y() + (pty * textureSize.y());
2251 tm.coords[1][2] = oldTrans.y() + (pty - trans2.y()) * textureSize.y();
2252 // center.y() = oldCenter.y() + (pty - trans2.y());
2255 //Need to update center.x/y() so that the widget translates as well. Also, oldCenter
2256 //is badly named... Should be oldTrans or something like that... !!! FIX !!!
2257 //Changing center.x/y() here doesn't seem to change anything... :-/
2258 UpdateControlPoints();
2262 // Shamus: New rotate code
2263 int cx = (int)(windowSize.x() * (center.x() - extents.minX) / extents.width());
2264 int cy = (int)(windowSize.y() * (center.y() - extents.minY) / extents.height());
2265 Vector3 v1(dragPoint.x() - cx, dragPoint.y() - cy, 0), v2(e->x - cx, e->y - cy, 0);
2267 vector3_normalise(v1);
2268 vector3_normalise(v2);
2269 float c = vector3_dot(v1, v2);
2270 Vector3 cross = vector3_cross(v1, v2);
2271 float s = vector3_length(cross);
2276 // Problem with this: arcsin/cos seems to only return -90 to 90 and 0 to 180...
2277 // Can't derive angle from that!
2279 //rotationAngle = asin(s);// * 180.0f / 3.141592653589f;
2280 rotationAngle = acos(c);
2281 //rotationAngle2 = asin(s);
2283 rotationAngle = -rotationAngle;
2285 //NO! DOESN'T WORK! rotationAngle -= 45.0f * DEG_TO_RAD;
2288 /*c = cos(rotationAngle - oldRotationAngle);
2289 s = sin(rotationAngle - oldRotationAngle);
2290 rotationAngle += oldRotationAngle;
2291 //c += cos(oldRotationAngle);
2292 //s += sin(oldRotationAngle);
2293 //rotationAngle += oldRotationAngle;
2296 //rotationAngle %= 2.0 * PI;//*/
2298 //This is wrong... Hmm...
2299 //It seems to shear the texture instead of rotating it... !!! FIX !!!
2300 // Now it rotates correctly. Seems TTimo was overcomplicating things here... ;-)
2302 // Seems like what needs to happen here is multiplying these rotations by tm... !!! FIX !!!
2304 // See brush_primit.cpp line 244 (Texdef_EmitTextureCoordinates()) for where texcoords come from...
2306 tm.coords[0][0] = c;
2307 tm.coords[0][1] = s;
2308 tm.coords[1][0] = -s;
2309 tm.coords[1][1] = c;
2310 //It doesn't work anymore... Dunno why...
2311 //tm.coords[0][2] = -trans.x(); // This works!!! Yeah!!!
2312 //tm.coords[1][2] = -trans.y();
2314 //tm.coords[0][2] = rotationPoint.x(); // This works, but strangely...
2315 //tm.coords[1][2] = rotationPoint.y();
2316 //tm.coords[0][2] = 0;// center.x() / 2.0f;
2317 //tm.coords[1][2] = 0;// center.y() / 2.0f;
2319 //tm.coords[0][2] = -(center.x() * textureSize.x());
2320 //tm.coords[1][2] = -(center.y() * textureSize.y());
2321 //Eh? No, but seems to be getting closer...
2322 /*float ptx = e->x / windowSize.x() * extents.width() + extents.minX;
2323 float pty = e->y / windowSize.y() * extents.height() + extents.minY;
2324 tm.coords[0][2] = -c * center.x() - s * center.y() + ptx;
2325 tm.coords[1][2] = s * center.x() - c * center.x() + pty;//*/
2326 //Kinda works, but center drifts around on non-square textures...
2327 /*tm.coords[0][2] = (-c * center.x() - s * center.y()) * textureSize.x();
2328 tm.coords[1][2] = ( s * center.x() - c * center.y()) * textureSize.y();//*/
2329 //Rotates correctly, but not around the actual center of the face's points...
2330 /*tm.coords[0][2] = -c * center.x() * textureSize.x() - s * center.y() * textureSize.y();
2331 tm.coords[1][2] = s * center.x() * textureSize.x() - c * center.y() * textureSize.y();//*/
2333 tm.coords[0][2] = (-c * center.x() * textureSize.x() - s * center.y() * textureSize.y()) + center.x() * textureSize.x();
2334 tm.coords[1][2] = ( s * center.x() * textureSize.x() - c * center.y() * textureSize.y()) + center.y() * textureSize.y();//*/
2335 //This doesn't work...
2336 //And this is the wrong place for this anyway (I'm pretty sure).
2337 /*tm.coords[0][2] += oldCenter.x();
2338 tm.coords[1][2] += oldCenter.y();//*/
2339 UpdateControlPoints(); // will cause a redraw
2344 else // Check for widget mouseovers
2347 float nx = e->x / windowSize.x() * extents.width() + extents.minX;
2348 float ny = e->y / windowSize.y() * extents.height() + extents.minY;
2349 // Translate nx/y to the "center" point...
2352 ny = -ny; // Flip Y-axis so that increasing numbers move up
2354 tran.x() = tm.coords[0][0] * nx + tm.coords[0][1] * ny;
2355 tran.y() = tm.coords[1][0] * nx + tm.coords[1][1] * ny;
2356 //This doesn't seem to generate a valid distance from the center--for some reason it
2357 //calculates a fixed number every time
2358 //Look at nx/y above: they're getting fixed there! !!! FIX !!! [DONE]
2359 float dist = sqrt((nx * nx) + (ny * ny));
2360 // Normalize to the 2.0 = height standard (for now)
2361 //globalOutputStream() << "--> Distance before: " << dist;
2362 dist = dist * 2.0f / extents.height();
2363 //globalOutputStream() << ". After: " << dist;
2364 tran.x() = tran.x() * 2.0f / extents.height();
2365 tran.y() = tran.y() * 2.0f / extents.height();
2366 //globalOutputStream() << ". Trans: " << tran.x() << ", " << tran.y() << "\n";
2368 //Let's try this instead...
2369 //Interesting! It seems that e->x/y are rotated
2370 //(no, they're not--the TM above is what's doing it...)
2371 nx = ((e->x / windowSize.y()) * 2.0f) - (windowSize.x() / windowSize.y());
2372 ny = ((e->y / windowSize.y()) * 2.0f) - (windowSize.y() / windowSize.y());
2374 //Cool! It works! Now just need to do rotation...
2376 rotating = translatingX = translatingY = scalingX = scalingY
2377 = resizingX = resizingY = false;
2379 if (dist < (gridRadius * 0.16f))
2381 translatingX = translatingY = true;
2383 else if (dist > (gridRadius * 0.16f) && dist < (gridRadius * 1.10f)
2384 && fabs(ny) < (gridRadius * 0.05f) && nx > 0)
2386 translatingX = true;
2388 else if (dist > (gridRadius * 0.16f) && dist < (gridRadius * 1.10f)
2389 && fabs(nx) < (gridRadius * 0.05f) && ny > 0)
2391 translatingY = true;
2393 // Should tighten up the angle on this, or put this test after the axis tests...
2394 else if (tran.x() > 0 && tran.y() > 0
2395 && (dist > (gridRadius * 0.82f) && dist < (gridRadius * 0.98f)))
2408 //It seems the fake tex coords conversion is screwing this stuff up... !!! FIX !!!
2409 //This is still wrong... Prolly need to do something with the oldScaleX/Y stuff...
2410 void flipX(GtkToggleButton *, gpointer)
2412 // globalOutputStream() << "--> Flip X...\n";
2414 // SurfaceInspector_GetSelectedBPTexdef(); // Refresh g_selectedBrushPrimitTexdef...
2415 // tm.coords[0][0] = -tm.coords[0][0];
2416 // tm.coords[1][0] = -tm.coords[1][0];
2417 // tm.coords[0][0] = -tm.coords[0][0]; // This should be correct now...Nope.
2418 // tm.coords[1][1] = -tm.coords[1][1];
2419 tm.coords[0][0] = -tm.coords[0][0]; // This should be correct now...
2420 tm.coords[1][0] = -tm.coords[1][0];
2421 // tm.coords[2][0] = -tm.coords[2][0];//wil wok? no.
2422 UpdateControlPoints();
2425 void flipY(GtkToggleButton *, gpointer)
2427 // globalOutputStream() << "--> Flip Y...\n";
2428 // tm.coords[0][1] = -tm.coords[0][1];
2429 // tm.coords[1][1] = -tm.coords[1][1];
2430 // tm.coords[0][1] = -tm.coords[0][1]; // This should be correct now...Nope.
2431 // tm.coords[1][0] = -tm.coords[1][0];
2432 tm.coords[0][1] = -tm.coords[0][1]; // This should be correct now...
2433 tm.coords[1][1] = -tm.coords[1][1];
2434 // tm.coords[2][1] = -tm.coords[2][1];//wil wok? no.
2435 UpdateControlPoints();
2438 } // end namespace TexTool