ubergames/gtkradiant
0
0
Fork 0
mirror of https://github.com/UberGames/GtkRadiant.git synced 2024-11-10 06:31:41 +00:00
Code Issues Projects Releases Packages Wiki Activity
gtkradiant/radiant/surfacedialog.cpp
Timothee "TTimo" Besset 0389190dce Merge branch 'master' of https://github.com/jdolan/GtkRadiant.git
2013-07-07 14:13:17 -05:00

1092 lines
39 KiB
C++
Raw Permalink Blame History

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
This file is part of GtkRadiant.
GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
//
// Surface Dialog
//
// Leonardo Zide (leo@lokigames.com)
//
#include <gdk/gdkkeysyms.h>
#include "stdafx.h"
#include "surfacedialog.h"
#include <glib/gi18n.h>
SurfaceDlg g_dlgSurface;
/////////////////////////////////////////////////////////////////////////////
// surface properties plugin
/*
===================================================
SURFACE INSPECTOR
===================================================
*/
// the texdef to switch back to when the OnCancel is called
texdef_t g_old_texdef;
// when != NULL, this thing means the surface inspector is currently being displayed
// NOTE a boolean flag would have been more explicit, this is totally so ugly
GtkWidget* g_surfwin = NULL;
// turn on/off processing of the "changed" "value_changed" messages
// (need to turn off when we are feeding data in)
bool g_bListenChanged = true;
// the struct used to store the increments (saved in registry)
texdef_t *l_pIncrement = &g_qeglobals.d_savedinfo.m_SIIncrement;
// turn on/off listening of the update messages
bool g_bListenUpdate = true;
#ifdef _DEBUG
// experimental stuff, work directly on BP
static void OnTest( GtkWidget *widget, gpointer data ){
if ( !g_qeglobals.m_bBrushPrimitMode ) {
Sys_FPrintf( SYS_WRN, "BP mode required\n" );
return;
}
if ( g_ptrSelectedFaces.GetSize() != 1 ) {
Sys_FPrintf( SYS_WRN, "Expected single face selection\n" );
return;
}
//brush_t *b = reinterpret_cast<brush_t*>( g_ptrSelectedFaceBrushes.GetAt( 0 ) );
face_t *selFace = reinterpret_cast<face_t*>( g_ptrSelectedFaces.GetAt( 0 ) );
// get the ST axis base for the face
vec3_t texS,texT;
ComputeAxisBase( selFace->plane.normal, texS, texT );
// find ST coordinates for the center of the face
float Os = 0,Ot = 0;
int i;
for ( i = 0; i < selFace->face_winding->numpoints; i++ )
{
Os += DotProduct( selFace->face_winding->points[i],texS );
Ot += DotProduct( selFace->face_winding->points[i],texT );
}
Os /= selFace->face_winding->numpoints;
Ot /= selFace->face_winding->numpoints;
brushprimit_texdef_t *pBP = &selFace->brushprimit_texdef;
// (FIXME: initial version, before axis base change optimize)
// we need to compute our BP matrix in this new axis base (O,texS,texT)
// the general case if BPO = M * BP * M^-1
// where BPO is transformation expressed in (O,texS,texT)
// M is the axis base change from (origin,texS,texT) to (O,texS,texT)
// here we have a special case, M is a translation and it's inverse is easy
vec_t BPO[2][3];
vec_t aux[2][3];
vec_t m[2][3];
memset( &m, 0, sizeof( vec_t ) * 6 );
m[0][0] = 1; m[1][1] = 1; m[0][2] = -Os; m[1][2] = -Ot;
BPMatMul( m, pBP->coords, aux );
m[0][2] = Os; m[1][2] = Ot; // now M^-1
BPMatMul( aux, m, BPO );
#if 0
// apply a scaling
// scale factors against S and T axis, we apply on top of the existing matrix
// <1 will decrease the texel/world resolution, >1 will increase
float sS = 1.025,sT = 1.025;
BPMatScale( BPO,sS,sT );
#endif
#if 0
// apply a rotation
float theta = 5;
BPMatRotate( BPO,theta );
#endif
#if 0
// read the scale
ConvertTexMatWithQTexture( BPO, selFace->d_texture, aux, NULL );
// reset the scale (normalize the matrix)
vec_t v1,v2;
v1 = sqrt( aux[0][0] * aux[0][0] + aux[1][0] * aux[1][0] );
v2 = sqrt( aux[0][1] * aux[0][1] + aux[1][1] * aux[1][1] );
// if reading the scale values, we have them here:
Sys_Printf( "Current Scale: S: %g T: %g\n", v1, v2 );
return;
#endif
#if 1
// apply a given scale (on S and T)
ConvertTexMatWithQTexture( BPO, selFace->d_texture, aux, NULL );
// reset the scale (normalize the matrix)
vec_t v1,v2;
v1 = sqrt( aux[0][0] * aux[0][0] + aux[1][0] * aux[1][0] );
v2 = sqrt( aux[0][1] * aux[0][1] + aux[1][1] * aux[1][1] );
vec_t sS,sT;
// put the values for scale on S and T here:
sS = 1.2 / v1;
sT = 0.8 / v2;
aux[0][0] *= sS; aux[1][0] *= sS;
aux[0][1] *= sT; aux[1][1] *= sT;
ConvertTexMatWithQTexture( aux, NULL, BPO, selFace->d_texture );
#endif
// now BPO must be expressed back in (origin,texS,texT) axis base BP = M^-1 * BPO * M
BPMatMul( m, BPO, aux ); // m is M^-1
m[0][2] = -Os; m[1][2] = -Ot;
BPMatMul( aux, m, pBP->coords );
// now emit the coordinates on the winding
EmitBrushPrimitTextureCoordinates( selFace, selFace->face_winding );
Sys_UpdateWindows( W_CAMERA );
}
/*
FIXME: try again, there must be a silly mistake in the formula expansion
// we need to compute our BP matrix in this new axis base (O,texS,texT)
// the general case is BPO = M * BP * M^-1
// where BPO is transformation expressed in (O,texS,texT)
// M is the axis base change from (origin,texS,texT) to (O,texS,texT)
// here we have a special case, M is a translation and it's inverse is easy
// the M * BP * M^-1 formula can be expanded and simplified
vec_t BPO[2][3];
memcpy(&BPO, &pBP->coords, sizeof(vec_t)*6);
BPO[0][2] = Os*(pBP->coords[0][0]-1.0) + Ot*pBP->coords[0][1] + pBP->coords[0][2];
BPO[1][2] = Os*pBP->coords[1][0] + Ot*(pBP->coords[1][1]-1.0) + Ot*pBP->coords[1][2];
// apply a scaling
// scale factors against S and T axis, we apply on top of the existing matrix
// <1 will decrease the texel/world resolution, >1 will increase
float sS = 1.025,sT = 1.025;
BPMatScale(BPO,sS,sT);
// now BPO must be expressed back in (origin,texS,texT) axis base BP = M^-1 * BPO * M
// same expanded formula as above
memcpy(&pBP->coords, &BPO, sizeof(vec_t)*6);
pBP->coords[0][2] = Os*(1.0-BPO[0][0]) - Ot*BPO[0][1] + BPO[0][2];
pBP->coords[1][2] = -Os*BPO[1][0] + Ot*(1.0-BPO[1][1]) + BPO[1][2];
*/
/*
// initial version, before axis base change optimize
// we need to compute our BP matrix in this new axis base (O,texS,texT)
// the general case if BPO = M * BP * M^-1
// where BPO is transformation expressed in (O,texS,texT)
// M is the axis base change from (origin,texS,texT) to (O,texS,texT)
// here we have a special case, M is a translation and it's inverse is easy
vec_t BPO[2][3];
vec_t aux[2][3];
vec_t m[2][3];
memset(&m, 0, sizeof(vec_t)*6);
m[0][0] = 1; m[1][1] = 1; m[0][2] = -Os; m[1][2] = -Ot;
BPMatMul(m, pBP->coords, aux);
m[0][2] = Os; m[1][2] = Ot; // now M^-1
BPMatMul(aux, m, BPO);
// apply a scaling
// scale factors against S and T axis, we apply on top of the existing matrix
// <1 will decrease the texel/world resolution, >1 will increase
float sS = 1.025,sT = 1.025;
BPMatScale(BPO,sS,sT);
// now BPO must be expressed back in (origin,texS,texT) axis base BP = M^-1 * BPO * M
BPMatMul(m, BPO, aux); // m is M^-1
m[0][2] = -Os; m[1][2] = -Ot;
BPMatMul(aux, m, pBP->coords);
*/
#endif
static void OnDone( GtkWidget *widget, gpointer data ){
g_dlgSurface.GetTexMods();
g_dlgSurface.HideDlg();
Sys_UpdateWindows( W_ALL );
}
// OnUpdate is called when something is changed in the dialog
// and must be reflected in the views. But it's not a change
// so important, so the system will try to undo our last do before applying the new changes
static void OnUpdate( GtkWidget *widget, gpointer data ){
if ( !g_bListenChanged ) {
return;
}
if ( OnlyPatchesSelected() ) {
//++timo possible bug or misfeature in our gtk_MessageBox here..
// gtk_MessageBox("The surface inspector doesn't work for patches, use the patch inspector instead (Shift+S)", "Surface Inspector", MB_OK );
Sys_Printf( "The surface inspector doesn't work for patches, use the patch inspector instead (Shift+S)\n" );
return;
}
// avoid long delays on slow computers
while ( gtk_events_pending() )
gtk_main_iteration();
g_dlgSurface.GetTexMods();
Sys_UpdateWindows( W_CAMERA );
}
// reflect the current changes in the views, and make sure
// the changes are stored in the undo.
static void OnApply( GtkWidget *widget, gpointer data ){
if ( !g_bListenChanged ) {
return;
}
g_dlgSurface.GetTexMods();
g_dlgSurface.m_nUndoId = 0; // that way we are sure we won't call undo
Sys_UpdateWindows( W_CAMERA );
}
// we use OnTextureKey to detect when the user edits something in the texture widget
// in which case next 'Enter' will be interpreted as a OnApply instead of a OnDone
static gint OnTextureKey( GtkWidget* widget, GdkEventKey* event, gpointer data ){
#ifdef DBG_SI
Sys_Printf( "OnTextureKey\n" );
#endif
if ( event->keyval != GDK_Return ) {
g_dlgSurface.m_bEditingTextureWidget = true;
}
return FALSE;
}
static void OnCancel( GtkWidget *widget, gpointer data ){
g_qeglobals.d_texturewin.texdef = g_old_texdef;
// cancel the last do if we own it
if ( g_dlgSurface.m_nUndoId == Undo_GetUndoId() ) {
#ifdef DBG_SI
Sys_Printf( "OnCancel calling Undo_Undo\n" );
#endif
g_bListenUpdate = false;
Undo_Undo();
g_bListenUpdate = true;
g_dlgSurface.m_nUndoId = 0;
}
g_dlgSurface.HideDlg();
}
static gint OnDialogKey( GtkWidget* widget, GdkEventKey* event, gpointer data ) {
if ( g_surfwin ) {
if ( event->keyval == GDK_Return ) {
if ( g_dlgSurface.m_bEditingTextureWidget ) {
OnApply( NULL, NULL );
g_dlgSurface.m_bEditingTextureWidget = false;
} else {
OnDone( NULL, NULL );
}
return TRUE;
}
if ( event->keyval == GDK_Escape ) {
OnCancel( NULL, NULL );
return TRUE;
}
}
return FALSE;
}
// the widget can be one of hshift, vshift, hscale, vscale, rotate
// we use the g_bListenChanged flag to ignore when changing stuff ourselves
static void OnIncrementChanged( GtkWidget *widget, gpointer data ){
if ( !g_bListenChanged ) {
return;
}
#ifdef DBG_SI
Sys_Printf( "OnIncrementChanged\n" );
#endif
gfloat val = 0;
sscanf( gtk_entry_get_text( GTK_ENTRY( widget ) ), "%g", &val );
// now push it into the appropriate spin button
GtkAdjustment * adjust;
if ( widget == g_dlgSurface.GetDlgWidget( "hshift_inc" ) ) {
l_pIncrement->shift[0] = val;
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "hshift" ) ) );
adjust->step_increment = l_pIncrement->shift[0];
}
else if ( widget == g_dlgSurface.GetDlgWidget( "vshift_inc" ) ) {
l_pIncrement->shift[1] = val;
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "vshift" ) ) );
adjust->step_increment = l_pIncrement->shift[1];
}
else if ( widget == g_dlgSurface.GetDlgWidget( "hscale_inc" ) ) {
l_pIncrement->scale[0] = val;
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "hscale" ) ) );
adjust->step_increment = l_pIncrement->scale[0];
}
else if ( widget == g_dlgSurface.GetDlgWidget( "vscale_inc" ) ) {
l_pIncrement->scale[1] = val;
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "vscale" ) ) );
adjust->step_increment = l_pIncrement->scale[1];
}
else if ( widget == g_dlgSurface.GetDlgWidget( "rotate_inc" ) ) {
l_pIncrement->rotate = val;
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "rotate" ) ) );
adjust->step_increment = l_pIncrement->rotate;
}
}
// make the shift increments match the grid settings
// the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size
// this depends on a scale value if you have selected a particular texture on which you want it to work:
// we move the textures in pixels, not world units. (i.e. increment values are in pixel)
// depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize
// increment * scale = gridsize
// hscale and vscale are optional parameters, if they are zero they will be set to the default scale
// NOTE: the default scale depends if you are using BP mode or regular.
// For regular it's 0.5f (128 pixels cover 64 world units), for BP it's simply 1.0f
// see fenris #2810
void DoSnapTToGrid( float hscale, float vscale ){
if ( hscale == 0.0f ) {
( g_qeglobals.m_bBrushPrimitMode ) ? hscale = 1.0f : hscale = 0.5f;
}
if ( vscale == 0.0f ) {
( g_qeglobals.m_bBrushPrimitMode ) ? vscale = 1.0f : vscale = 0.5f;
}
#ifdef _DEBUG
Sys_Printf( "DoSnapTToGrid: hscale %g vscale %g\n", hscale, vscale );
#endif
l_pIncrement->shift[0] = (int) ( (float)g_qeglobals.d_gridsize / hscale );
l_pIncrement->shift[1] = (int) ( (float)g_qeglobals.d_gridsize / vscale );
// now some update work
// FIXME: doesn't look good here, seems to be called several times
g_dlgSurface.SetTexMods();
}
// make the shift increments match the grid settings
// the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size
// this depends on the current texture scale used?
// we move the textures in pixels, not world units. (i.e. increment values are in pixel)
// depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize
// increment * scale = gridsize
static void OnBtnMatchGrid( GtkWidget *widget, gpointer data ){
float hscale, vscale;
hscale = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "hscale" ) ) );
vscale = gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( g_dlgSurface.GetDlgWidget( "vscale" ) ) );
if ( hscale == 0.0f || vscale == 0.0f ) {
Sys_Printf( "ERROR: unexpected scale == 0.0f\n" );
return;
}
DoSnapTToGrid( hscale, vscale );
}
void UpdateSurfaceDialog(){
if ( !g_bListenUpdate ) {
return;
}
g_SurfaceTable.m_pfnUpdateSurfaceDialog();
}
// DoSurface will always try to show the surface inspector
// or update it because something new has been selected
void DoSurface( void ){
#ifdef DBG_SI
Sys_Printf( "DoSurface\n" );
#endif
g_SurfaceTable.m_pfnDoSurface();
return;
}
void ToggleSurface(){
g_SurfaceTable.m_pfnToggleSurface();
return;
}
// NOTE: will raise and show the Surface inspector and exec fit for patches and brushes
void SurfaceDlgFitAll(){
g_SurfaceTable.m_pfnSurfaceDlgFitAll();
return;
}
static void OnBtnPatchdetails( GtkWidget *widget, gpointer data ){
Patch_NaturalizeSelected( true );
Sys_UpdateWindows( W_ALL );
}
static void OnBtnPatchnatural( GtkWidget *widget, gpointer data ){
Patch_NaturalizeSelected();
Sys_UpdateWindows( W_ALL );
}
static void OnBtnPatchreset( GtkWidget *widget, gpointer data ){
float fx, fy;
if ( DoTextureLayout( &fx, &fy ) == IDOK ) {
Patch_ResetTexturing( fx, fy );
}
Sys_UpdateWindows( W_ALL );
}
static void OnBtnPatchFit( GtkWidget *widget, gpointer data ){
Patch_ResetTexturing( 1.0, 1.0 );
Sys_UpdateWindows( W_ALL );
}
static void OnBtnAxial( GtkWidget *widget, gpointer data ){
Select_SetTexture( &g_qeglobals.d_texturewin.texdef, &g_qeglobals.d_texturewin.brushprimit_texdef, true );
g_dlgSurface.SetTexMods();
Sys_UpdateWindows( W_ALL );
}
static void OnBtnFaceFit( GtkWidget *widget, gpointer data ){
g_dlgSurface.UpdateData( TRUE );
if ( g_ptrSelectedFaces.GetSize() == 0 ) {
brush_t *b;
for ( b = selected_brushes.next ; b != &selected_brushes ; b = b->next )
{
for ( face_t* pFace = b->brush_faces; pFace; pFace = pFace->next )
{
g_ptrSelectedFaces.Add( pFace );
g_ptrSelectedFaceBrushes.Add( b );
}
}
Select_FitTexture( g_dlgSurface.m_nHeight, g_dlgSurface.m_nWidth );
g_dlgSurface.SetTexMods();
g_ptrSelectedFaces.RemoveAll();
}
else
{
Select_FitTexture( g_dlgSurface.m_nHeight, g_dlgSurface.m_nWidth );
g_dlgSurface.SetTexMods();
}
Sys_UpdateWindows( W_ALL );
}
// =============================================================================
// SurfaceDialog class
SurfaceDlg::SurfaceDlg (){
m_nHeight = 1;
m_nWidth = 1;
m_nUndoId = 0;
}
void SurfaceDlg::ShowDlg(){
Dialog::ShowDlg();
if ( GetWidget() == NULL ) {
Create();
}
g_surfwin = GetWidget();
}
void SurfaceDlg::HideDlg(){
g_surfwin = NULL;
Dialog::HideDlg();
}
GtkWidget* SurfaceDlg::GetWidget(){
return g_SurfaceTable.m_pfnGet_SI_Module_Widget();
}
// set default values for increments (shift scale and rot)
// this is called by the prefs code if can't find the values
void SurfaceDlg::InitDefaultIncrement( texdef_t *tex ){
tex->SetName( "foo" );
tex->shift[0] = 8;
tex->shift[1] = 8;
tex->scale[0] = 0.25;
tex->scale[1] = 0.25;
tex->rotate = 10;
}
void SurfaceDlg::BuildDialog() {
GtkWidget *dlg, *vbox, *hbox2, *frame, *table, *label;
GtkWidget *button, *entry, *spin;
dlg = m_pWidget;
load_window_pos( dlg, g_PrefsDlg.mWindowInfo.posSurfaceWnd );
gtk_window_set_title( GTK_WINDOW( dlg ), _( "Surface inspector" ) );
//g_signal_connect (G_OBJECT (dlg), "delete_event", G_CALLBACK (OnCancel), NULL);
// we catch 'Enter' and interpret is as OnDone
gtk_signal_connect( GTK_OBJECT( dlg ), "key_press_event", GTK_SIGNAL_FUNC( OnDialogKey ), NULL );
gtk_window_set_transient_for( GTK_WINDOW( dlg ), GTK_WINDOW( g_pParentWnd->m_pWidget ) );
// replaced by only the vbox:
vbox = gtk_vbox_new( FALSE, 5 );
gtk_widget_show( vbox );
gtk_container_add( GTK_CONTAINER( dlg ), vbox );
gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );
hbox2 = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox2 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox2, FALSE, TRUE, 0 );
label = gtk_label_new( _( "Texture" ) );
gtk_widget_show( label );
gtk_box_pack_start( GTK_BOX( hbox2 ), label, FALSE, TRUE, 0 );
entry = gtk_entry_new();
gtk_signal_connect( GTK_OBJECT( entry ), "key_press_event", GTK_SIGNAL_FUNC( OnTextureKey ), NULL );
gtk_widget_show( entry );
gtk_box_pack_start( GTK_BOX( hbox2 ), entry, TRUE, TRUE, 0 );
g_object_set_data( G_OBJECT( m_pWidget ), "texture", entry );
// table = gtk_table_new (5, 4, FALSE);
table = gtk_table_new( 6, 4, FALSE );
gtk_widget_show( table );
gtk_box_pack_start( GTK_BOX( vbox ), table, FALSE, TRUE, 0 );
gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
label = gtk_label_new( _( "Horizontal shift" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 8 ) ), 0, 0 );
g_object_set_data( G_OBJECT( dlg ), "hshift", spin );
gtk_signal_connect( GTK_OBJECT( gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ) ), "value_changed",
GTK_SIGNAL_FUNC( OnUpdate ), NULL );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 1, 2, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
label = gtk_label_new( _( "Step" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
entry = gtk_entry_new();
g_object_set_data( G_OBJECT( dlg ), "hshift_inc", entry );
gtk_signal_connect( GTK_OBJECT( entry ), "changed",
GTK_SIGNAL_FUNC( OnIncrementChanged ), NULL );
gtk_widget_show( entry );
gtk_table_attach( GTK_TABLE( table ), entry, 3, 4, 0, 1,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( entry, 50, -2 );
label = gtk_label_new( _( "Vertical shift" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 8 ) ), 0, 0 );
g_object_set_data( G_OBJECT( dlg ), "vshift", spin );
gtk_signal_connect( GTK_OBJECT( gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ) ), "value_changed",
GTK_SIGNAL_FUNC( OnUpdate ), NULL );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
label = gtk_label_new( _( "Step" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
entry = gtk_entry_new();
g_object_set_data( G_OBJECT( dlg ), "vshift_inc", entry );
gtk_signal_connect( GTK_OBJECT( entry ), "changed",
GTK_SIGNAL_FUNC( OnIncrementChanged ), NULL );
gtk_widget_show( entry );
gtk_table_attach( GTK_TABLE( table ), entry, 3, 4, 1, 2,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( entry, 50, -2 );
label = gtk_label_new( _( "Horizontal stretch" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -1000, 1000, 1, 10, 10 ) ), 0, 0 );
g_object_set_data( G_OBJECT( dlg ), "hscale", spin );
gtk_signal_connect( GTK_OBJECT( gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ) ), "value_changed",
GTK_SIGNAL_FUNC( OnUpdate ), NULL );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 1, 2, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
label = gtk_label_new( _( "Step" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 2, 3 );
entry = gtk_entry_new();
g_object_set_data( G_OBJECT( dlg ), "hscale_inc", entry );
gtk_signal_connect( GTK_OBJECT( entry ), "changed",
GTK_SIGNAL_FUNC( OnIncrementChanged ), NULL );
gtk_widget_show( entry );
gtk_table_attach( GTK_TABLE( table ), entry, 3, 4, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 2, 3 );
gtk_widget_set_usize( entry, 50, -2 );
label = gtk_label_new( _( "Vertical stretch" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 3, 4,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -1000, 1000, 1, 10, 10 ) ), 0, 0 );
g_object_set_data( G_OBJECT( dlg ), "vscale", spin );
gtk_signal_connect( GTK_OBJECT( gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ) ), "value_changed",
GTK_SIGNAL_FUNC( OnUpdate ), NULL );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 1, 2, 3, 4,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
label = gtk_label_new( _( "Step" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 3, 4,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
entry = gtk_entry_new();
g_object_set_data( G_OBJECT( dlg ), "vscale_inc", entry );
gtk_signal_connect( GTK_OBJECT( entry ), "changed",
GTK_SIGNAL_FUNC( OnIncrementChanged ), NULL );
gtk_widget_show( entry );
gtk_table_attach( GTK_TABLE( table ), entry, 3, 4, 3, 4,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( entry, 50, -2 );
label = gtk_label_new( _( "Rotate" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 4, 5,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -360, 360, 1, 10, 10 ) ), 1, 0 );
g_object_set_data( G_OBJECT( dlg ), "rotate", spin );
gtk_signal_connect( GTK_OBJECT( gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ) ), "value_changed",
GTK_SIGNAL_FUNC( OnUpdate ), NULL );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 1, 2, 4, 5,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( spin ), TRUE );
label = gtk_label_new( _( "Step" ) );
gtk_widget_show( label );
gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 4, 5,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
entry = gtk_entry_new();
g_object_set_data( G_OBJECT( dlg ), "rotate_inc", entry );
gtk_signal_connect( GTK_OBJECT( entry ), "changed",
GTK_SIGNAL_FUNC( OnIncrementChanged ), NULL );
gtk_widget_show( entry );
gtk_table_attach( GTK_TABLE( table ), entry, 3, 4, 4, 5,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( entry, 50, -2 );
// match grid button
button = gtk_button_new_with_label( _( "Match Grid" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 2, 4, 5, 6,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnMatchGrid ), NULL );
frame = gtk_frame_new( _( "Texturing" ) );
gtk_widget_show( frame );
gtk_box_pack_start( GTK_BOX( vbox ), frame, FALSE, TRUE, 0 );
table = gtk_table_new( 4, 4, FALSE );
gtk_widget_show( table );
gtk_container_add( GTK_CONTAINER( frame ), table );
gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
gtk_container_set_border_width( GTK_CONTAINER( table ), 5 );
label = gtk_label_new( "Brush" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Patch" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 2, 3,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( "Width" );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
label = gtk_label_new( _( "Height" ) );
gtk_widget_show( label );
gtk_table_attach( GTK_TABLE( table ), label, 3, 4, 0, 1,
(GtkAttachOptions) ( GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
button = gtk_button_new_with_label( _( "Axial" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnAxial ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "Fit" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 1, 2, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnFaceFit ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "CAP" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnPatchdetails ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "Set..." ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 1, 2, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnPatchreset ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "Natural" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 2, 3, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnPatchnatural ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "Fit" ) );
gtk_widget_show( button );
gtk_table_attach( GTK_TABLE( table ), button, 3, 4, 3, 4,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnBtnPatchFit ), NULL );
gtk_widget_set_usize( button, 60, -2 );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 1, 1, 32, 1, 10, 10 ) ), 1, 0 );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 2, 3, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
AddDialogData( spin, &m_nWidth, DLG_SPIN_INT );
spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 1, 1, 32, 1, 10, 10 ) ), 1, 0 );
gtk_widget_show( spin );
gtk_table_attach( GTK_TABLE( table ), spin, 3, 4, 1, 2,
(GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
(GtkAttachOptions) ( 0 ), 0, 0 );
gtk_widget_set_usize( spin, 60, -2 );
AddDialogData( spin, &m_nHeight, DLG_SPIN_INT );
hbox2 = gtk_hbox_new( FALSE, 5 );
gtk_widget_show( hbox2 );
gtk_box_pack_start( GTK_BOX( vbox ), hbox2, FALSE, TRUE, 0 );
button = gtk_button_new_with_label( _( "Done" ) );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox2 ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnDone ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "Apply" ) );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox2 ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnApply ), NULL );
gtk_widget_set_usize( button, 60, -2 );
button = gtk_button_new_with_label( _( "Cancel" ) );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox2 ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnCancel ), NULL );
gtk_widget_set_usize( button, 60, -2 );
// that's a bit of trashy stuff from Textool-v2 branch
#ifdef _DEBUG
// FIXME: testing only, scaling in BP mode
button = gtk_button_new_with_label( _( "Test" ) );
gtk_widget_show( button );
gtk_box_pack_start( GTK_BOX( hbox2 ), button, FALSE, FALSE, 0 );
gtk_signal_connect( GTK_OBJECT( button ), "clicked",
GTK_SIGNAL_FUNC( OnTest ), NULL );
gtk_widget_set_usize( button, 60, -2 );
#endif
// Initialize
SetTexMods();
}
/*
==============
SetTexMods
Set the fields to the current texdef (i.e. map/texdef -> dialog widgets)
if faces selected (instead of brushes) -> will read this face texdef, else current texdef
if only patches selected, will read the patch texdef
===============
*/
void SurfaceDlg::SetTexMods(){
texdef_t *pt;
brushprimit_texdef_t *bpt;
// local copy if a width=2 height=2 qtetxture_t is needed
brushprimit_texdef_t local_bp;
#ifdef DBG_SI
Sys_Printf( "SurfaceDlg::SetTexMods\n" );
#endif
if ( !g_surfwin ) {
return;
}
if ( g_ptrSelectedFaces.GetSize() > 0 ) {
face_t *selFace = reinterpret_cast<face_t*>( g_ptrSelectedFaces.GetAt( 0 ) );
pt = &selFace->texdef;
if ( g_qeglobals.m_bBrushPrimitMode ) {
// compute a texture matrix related to the default matrix width=2 height=2
ConvertTexMatWithQTexture( &selFace->brushprimit_texdef, selFace->d_texture, &local_bp, NULL );
bpt = &local_bp;
}
}
else
{
pt = &g_qeglobals.d_texturewin.texdef;
if ( g_qeglobals.m_bBrushPrimitMode ) {
bpt = &g_qeglobals.d_texturewin.brushprimit_texdef;
}
}
// brush primitive mode : compute fake shift scale rot representation
if ( g_qeglobals.m_bBrushPrimitMode ) {
TexMatToFakeTexCoords( bpt->coords, m_shift, &m_rotate, m_scale );
}
g_bListenChanged = false;
if ( strncmp( pt->GetName(), "textures/", 9 ) != 0 ) {
pt->SetName( SHADER_NOT_FOUND );
}
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "texture" ) ), pt->GetName() + 9 );
GtkSpinButton *spin;
spin = GTK_SPIN_BUTTON( GetDlgWidget( "hshift" ) );
gtk_spin_button_set_digits( spin, 2 );
if ( g_qeglobals.m_bBrushPrimitMode ) {
gtk_spin_button_set_value( spin, m_shift[0] );
}
else{
gtk_spin_button_set_value( spin, pt->shift[0] );
}
GtkAdjustment *adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) );
adjust->step_increment = l_pIncrement->shift[0];
char buf[10]; // got into snprintf paranoia after BoundChecker detected a stack overrun
#ifdef _WIN32
// TTimo: THIS IS UGLY
#define snprintf _snprintf
#endif
snprintf( buf, 10, "%g", l_pIncrement->shift[0] );
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "hshift_inc" ) ), buf );
spin = GTK_SPIN_BUTTON( GetDlgWidget( "vshift" ) );
gtk_spin_button_set_digits( spin, 2 );
if ( g_qeglobals.m_bBrushPrimitMode ) {
gtk_spin_button_set_value( spin, m_shift[1] );
}
else{
gtk_spin_button_set_value( spin, pt->shift[1] );
}
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) );
adjust->step_increment = l_pIncrement->shift[1];
snprintf( buf, 10, "%g", l_pIncrement->shift[1] );
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "vshift_inc" ) ), buf );
spin = GTK_SPIN_BUTTON( GetDlgWidget( "hscale" ) );
gtk_spin_button_set_digits( spin, 5 );
gtk_spin_button_set_value( spin, g_qeglobals.m_bBrushPrimitMode ? m_scale[0] : pt->scale[0] );
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) );
adjust->step_increment = l_pIncrement->scale[0];
snprintf( buf, 10, "%g", l_pIncrement->scale[0] );
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "hscale_inc" ) ), buf );
spin = GTK_SPIN_BUTTON( GetDlgWidget( "vscale" ) );
gtk_spin_button_set_digits( spin, 5 );
gtk_spin_button_set_value( spin, g_qeglobals.m_bBrushPrimitMode ? m_scale[1] : pt->scale[1] );
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) );
adjust->step_increment = l_pIncrement->scale[1];
snprintf( buf, 10, "%g", l_pIncrement->scale[1] );
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "vscale_inc" ) ), buf );
//++timo compute BProtate as int ..
spin = GTK_SPIN_BUTTON( GetDlgWidget( "rotate" ) );
gtk_spin_button_set_digits( spin, 2 );
gtk_spin_button_set_value( spin, g_qeglobals.m_bBrushPrimitMode ? m_rotate : pt->rotate );
adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) );
adjust->step_increment = l_pIncrement->rotate;
snprintf( buf, 10, "%g", l_pIncrement->rotate );
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "rotate_inc" ) ), buf );
g_bListenChanged = true;
// undo tricks: set the undo id to zero so we don't attempt to undo something that does not belong to us
m_nUndoId = 0;
// store the current texdef as our escape route if user hits OnCancel
g_old_texdef = g_qeglobals.d_texturewin.texdef;
// reset the Enter key behaviour flag
m_bEditingTextureWidget = false;
}
/*
==============
GetTexMods
Reads the fields to get the current texdef (i.e. widgets -> MAP)
in brush primitive mode, grab the fake shift scale rot and compute a new texture matrix
===============
*/
void SurfaceDlg::GetTexMods(){
char buffer[1024];
texdef_t *pt;
#ifdef DBG_SI
Sys_Printf( "SurfaceDlg::GetTexMods\n" );
#endif
if ( g_ptrSelectedFaces.GetSize() > 0 ) {
//++timo just a test, we disable the undo when working on selected faces
m_nUndoId = 0;
face_t *selFace = reinterpret_cast<face_t*>( g_ptrSelectedFaces.GetAt( 0 ) );
g_qeglobals.d_texturewin.texdef = selFace->texdef;
#ifdef DBG_SI
Sys_Printf( "g_qeglobals.d_texturewin.texdef = selFace->texdef\n" );
#endif
}
// else
// {
pt = &g_qeglobals.d_texturewin.texdef;
#ifdef DBG_SI
Sys_Printf( "pt = &g_qeglobals.d_texturewin.texdef\n" );
#endif
// }
const char* text = gtk_entry_get_text( GTK_ENTRY( GetDlgWidget( "texture" ) ) );
#ifdef DBG_SI
Sys_Printf( "pt->SetName(%s)\n", text );
#endif
// TTimo: detect and refuse invalid texture names (at least the ones with spaces)
if ( text[0] <= ' ' || strchr( text, ' ' ) ) {
Sys_FPrintf( SYS_WRN, "WARNING: spaces in shader names are not allowed, ignoring '%s'\n", text );
pt->SetName( SHADER_NOT_FOUND );
gtk_entry_set_text( GTK_ENTRY( GetDlgWidget( "texture" ) ), pt->GetName() );
}
else
{
strcpy( buffer, "textures/" );
strcpy( buffer + 9, text );
pt->SetName( buffer );
}
( g_qeglobals.m_bBrushPrimitMode ? m_shift[0] : pt->shift[0] ) =
gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "hshift" ) ) );
( g_qeglobals.m_bBrushPrimitMode ? m_shift[1] : pt->shift[1] ) =
gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "vshift" ) ) );
( g_qeglobals.m_bBrushPrimitMode ? m_scale[0] : pt->scale[0] ) =
gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "hscale" ) ) );
( g_qeglobals.m_bBrushPrimitMode ? m_scale[1] : pt->scale[1] ) =
gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "vscale" ) ) );
( g_qeglobals.m_bBrushPrimitMode ? m_rotate : pt->rotate ) =
gtk_spin_button_get_value_as_float( GTK_SPIN_BUTTON( GetDlgWidget( "rotate" ) ) );
// a local copy of the texture matrix, given for a qtexture_t with width=2 height=2
brushprimit_texdef_t local_bp;
brushprimit_texdef_t *bpt;
if ( g_qeglobals.m_bBrushPrimitMode ) {
face_t *selFace = NULL;
if ( g_ptrSelectedFaces.GetSize() > 0 ) {
selFace = reinterpret_cast<face_t*>( g_ptrSelectedFaces.GetAt( 0 ) );
bpt = &selFace->brushprimit_texdef;
}
else
{
bpt = &g_qeglobals.d_texturewin.brushprimit_texdef;
}
// compute texture matrix
// the matrix returned must be understood as a qtexture_t with width=2 height=2
FakeTexCoordsToTexMat( m_shift, m_rotate, m_scale, local_bp.coords );
// copy the texture matrix in the global struct
// fit the qtexture if we have a face selected, otherwise g_qeglobals.d_texturewin.brushprimit_texdef uses the basic qtexture_t with width=2 height=2
ConvertTexMatWithQTexture( &local_bp, NULL, bpt, ( ( selFace ) ? selFace->d_texture : NULL ) );
}
// we are gonna do stuff, if we own the last do we undo it first
if ( m_nUndoId != 0 ) {
// check the do we're about to undo is the one we pushed earlier
if ( m_nUndoId == Undo_GetUndoId() ) {
#ifdef DBG_SI
Sys_Printf( "GetTexMods calling Undo_Undo (silent)\n" );
#endif
g_bListenUpdate = false;
Undo_Undo( true );
g_bListenUpdate = true;
}
}
Select_SetTexture( pt,&local_bp );
m_nUndoId = Undo_GetUndoId();
}
void SurfaceDlg::FitAll(){
OnBtnFaceFit( NULL, NULL );
OnBtnPatchFit( NULL, NULL );
}
Reference in a new issue View git blame Copy permalink