Q3map2:

	* -brightness 0..alot, def 1: mimics q3map_lightmapBrightness, but globally + affects vertexlight
	* -contrast -255..255, def 0: lighting contrast
	* packer improvements

Radiant:

binds...
	* entity inspector: Tab enters Key field, toggles between key/value fields; Del deletes keys; Esc quits

misc...
	* improved mwheel 2d zoom by Neumond
	* +makeRoom: like hollow, but extrudes faces outwards; for making rooms
	* deactivating tex dirs tree after loading dir, so SPACE and ENTER aren't broken for 2D after that
	* Regular, RegularLeft layouts: smaller console, bigger tex browser
	* Rotate, Scale dialogs: values aren't erased on Enter, OK, Apply (are on cancel, esc)
	* Rotate dialog: fix: new value in focused field wasn't taking in account on Enter
	* +updating texture directories list on 'flush and reload shaders' (reloading shaderlist aswell)
	* NumLock perspective window fix
	* ctrl+k(ConnectEntities): friendlier to complex connections, takes in account existing keys
		(priority: target > targetname > none)
	* +'all Supported formats' default option in open dialogs
	* defaulted show light radii
	* camera fov: 90->110
	* cubic clip: off by default; bigger def dist; fixed button's shortcut tip
	* prefs: Min & Max texture thumbnail size + dependant on scale;
		def = *scale .5, min 48, max 160 (makes range 96-320 visually differentiated)

diff --git a/libs/gtkutil/accelerator.cpp b/libs/gtkutil/accelerator.cpp
index bba9ebe3434967f745066aa779cf3f9b89b96573..c49c2c703605621157ae252bb7361584f180bf3e 100644 (file)
--- a/libs/gtkutil/accelerator.cpp
+++ b/libs/gtkutil/accelerator.cpp
@@ -365,7 +365,9 @@ void Keys_releaseAll( PressedKeys::Keys& keys, guint state ){
 
 gboolean PressedKeys_key_press( GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys ){
        //globalOutputStream() << "pressed: " << event->keyval << "\n";
-       return event->state == 0 && Keys_press( pressedKeys->keys, event->keyval );
+       //return event->state == 0 && Keys_press( pressedKeys->keys, event->keyval );
+       //NumLock perspective window fix
+       return ( event->state & ALLOWED_MODIFIERS ) == 0 && Keys_press( pressedKeys->keys, event->keyval );
 }
 
 gboolean PressedKeys_key_release( GtkWidget* widget, GdkEventKey* event, PressedKeys* pressedKeys ){

diff --git a/libs/gtkutil/filechooser.cpp b/libs/gtkutil/filechooser.cpp
index d65d310ca567dc3eac3d47da95ccb6b946f37b56..82ba697b78b963cff3c1ccd3f210f147b43fcb03 100644 (file)
--- a/libs/gtkutil/filechooser.cpp
+++ b/libs/gtkutil/filechooser.cpp
@@ -191,6 +191,15 @@ const char* file_dialog_show( GtkWidget* parent, bool open, const char* title, c
        // we should add all important paths as shortcut folder...
        // gtk_file_chooser_add_shortcut_folder(GTK_FILE_CHOOSER(dialog), "/tmp/", NULL);
 
+       if ( open && masks.m_filters.size() > 1 ){
+               GtkFileFilter* filter = gtk_file_filter_new();
+               gtk_file_filter_set_name( filter, "Supported formats" );
+               for ( std::size_t i = 0; i < masks.m_filters.size(); ++i )
+               {
+                       gtk_file_filter_add_pattern( filter, masks.m_filters[i].c_str() );
+               }
+               gtk_file_chooser_add_filter( GTK_FILE_CHOOSER( dialog ), filter );
+       }
 
        for ( std::size_t i = 0; i < masks.m_filters.size(); ++i )
        {
@@ -205,7 +214,7 @@ const char* file_dialog_show( GtkWidget* parent, bool open, const char* title, c
 
                if ( !string_equal( pattern, "*" ) ) {
                        GtkFileFilter* filter = gtk_file_chooser_get_filter( GTK_FILE_CHOOSER( dialog ) );
-                       if ( filter != 0 ) { // no filter set? some file-chooser implementations may allow the user to set no filter, which we treat as 'all files'
+                       if ( filter != 0 && !string_equal( gtk_file_filter_get_name( filter ), "Supported formats" ) ) { // no filter set? some file-chooser implementations may allow the user to set no filter, which we treat as 'all files'
                                type = masks.GetTypeForGTKMask( gtk_file_filter_get_name( filter ) ).m_type;
                                // last ext separator
                                const char* extension = path_get_extension( g_file_dialog_file );

diff --git a/plugins/entity/entity.cpp b/plugins/entity/entity.cpp
index 745fad07119dffc7572a71a0ecd0b646a97c5813..db0e16b47f316d75871296b88626109c9a2492a4 100644 (file)
--- a/plugins/entity/entity.cpp
+++ b/plugins/entity/entity.cpp
@@ -113,7 +113,7 @@ Counter* EntityKeyValues::m_counter = 0;
 bool g_showNames = true;
 bool g_showAngles = true;
 bool g_newLightDraw = true;
-bool g_lightRadii = false;
+bool g_lightRadii = true;
 
 class ConnectEntities
 {
@@ -208,22 +208,48 @@ void connectEntities( const scene::Path& path, const scene::Path& targetPath, in
        else
        {
                ConnectEntities connector( e1, e2, index );
-               const char* value = e2->getKeyValue( "targetname" );
-               if ( !string_empty( value ) ) {
-                       connector.connect( value );
+               //killconnect
+               if( index == 1 ){
+                       const char* value = e2->getKeyValue( "targetname" );
+                       if ( !string_empty( value ) ) {
+                               connector.connect( value );
+                       }
+                       else
+                       {
+                               const char* type = e2->getKeyValue( "classname" );
+                               if ( string_empty( type ) ) {
+                                       type = "t";
+                               }
+                               StringOutputStream key( 64 );
+                               key << type << "1";
+                               GlobalNamespace().makeUnique( key.c_str(), ConnectEntities::ConnectCaller( connector ) );
+                       }
                }
-               else
-               {
-                       const char* type = e2->getKeyValue( "classname" );
-                       if ( string_empty( type ) ) {
-                               type = "t";
+               //normal connect
+               else{
+                       //prioritize existing target key
+                       //checking, if ent got other connected ones already, could be better solution
+                       const char* value = e1->getKeyValue( "target" );
+                       if ( !string_empty( value ) ) {
+                               connector.connect( value );
+                       }
+                       else{
+                               value = e2->getKeyValue( "targetname" );
+                               if ( !string_empty( value ) ) {
+                                       connector.connect( value );
+                               }
+                               else{
+                                       const char* type = e2->getKeyValue( "classname" );
+                                       if ( string_empty( type ) ) {
+                                               type = "t";
+                                       }
+                                       StringOutputStream key( 64 );
+                                       key << type << "1";
+                                       GlobalNamespace().makeUnique( key.c_str(), ConnectEntities::ConnectCaller( connector ) );
+                               }
                        }
-                       StringOutputStream key( 64 );
-                       key << type << "1";
-                       GlobalNamespace().makeUnique( key.c_str(), ConnectEntities::ConnectCaller( connector ) );
                }
        }
-
        SceneChangeNotify();
 }
 void setLightRadii( bool lightRadii ){

diff --git a/radiant/camwindow.cpp b/radiant/camwindow.cpp
index 4d9ea736c7e37f28198ee982d2c31295f96efbd6..f657551be26e2429edc9559e3b5b94e19fb4d950 100644 (file)
--- a/radiant/camwindow.cpp
+++ b/radiant/camwindow.cpp
@@ -88,7 +88,7 @@ struct camwindow_globals_private_t
                m_nAngleSpeed( 3 ),
                m_bCamInverseMouse( false ),
                m_bCamDiscrete( true ),
-               m_bCubicClipping( true ),
+               m_bCubicClipping( false ),
                m_showStats( true ),
                m_nStrafeMode( 0 ){
        }
@@ -170,7 +170,7 @@ struct camera_t
                color( 0, 0, 0 ),
                movementflags( 0 ),
                m_keymove_handler( 0 ),
-               fieldOfView( 90.0f ),
+               fieldOfView( 110.0f ),
                m_mouseMove( motionDelta, this ),
                m_view( view ),
                m_update( update ){
@@ -1664,7 +1664,7 @@ void Camera_ToggleFarClip(){
 
 
 void CamWnd_constructToolbar( GtkToolbar* toolbar ){
-       toolbar_append_toggle_button( toolbar, "Cubic clip the camera view (\\)", "view_cubicclipping.bmp", "ToggleCubicClip" );
+       toolbar_append_toggle_button( toolbar, "Cubic clip the camera view (Ctrl + \\)", "view_cubicclipping.bmp", "ToggleCubicClip" );
 }
 
 void CamWnd_registerShortcuts(){

diff --git a/radiant/camwindow.h b/radiant/camwindow.h
index 8e578c8598fb830eba65750c7d9773065370e4af..1101d4310c249b6504bf81515f52416ddb0de125 100644 (file)
--- a/radiant/camwindow.h
+++ b/radiant/camwindow.h
@@ -73,7 +73,7 @@ struct camwindow_globals_t
        camwindow_globals_t() :
                color_cameraback( 0.25f, 0.25f, 0.25f ),
                color_selbrushes3d( 1.0f, 0.f, 0.f ),
-               m_nCubicScale( 13 ){
+               m_nCubicScale( 14 ){
        }
 
 };

diff --git a/radiant/csg.cpp b/radiant/csg.cpp
index aab9caa573972a18d36e6ac677f1d095b168dd50..68349f240ec910697f6f450310fbc98c57062ecf 100644 (file)
--- a/radiant/csg.cpp
+++ b/radiant/csg.cpp
@@ -29,11 +29,13 @@
 #include "brushmanip.h"
 #include "brushnode.h"
 #include "grid.h"
-/*
+
 void Face_makeBrush( Face& face, const Brush& brush, brush_vector_t& out, float offset ){
        if ( face.contributes() ) {
                out.push_back( new Brush( brush ) );
                Face* newFace = out.back()->addFace( face );
+               face.getPlane().offset( -offset );
+               face.planeChanged();
                if ( newFace != 0 ) {
                        newFace->flipWinding();
                        newFace->getPlane().offset( offset );
@@ -41,46 +43,52 @@ void Face_makeBrush( Face& face, const Brush& brush, brush_vector_t& out, float
                }
        }
 }
-*/
 
-void Face_makeBrush( Face& face, const Brush& brush, brush_vector_t& out, float offset ){
+void Face_extrude( Face& face, const Brush& brush, brush_vector_t& out, float offset ){
        if ( face.contributes() ) {
+               face.getPlane().offset( offset );
                out.push_back( new Brush( brush ) );
-               //face.getPlane().offset( -offset );
-               //face.planeChanged();
+               face.getPlane().offset( -offset );
                Face* newFace = out.back()->addFace( face );
                if ( newFace != 0 ) {
                        newFace->flipWinding();
-                       newFace->getPlane().offset( offset );
                        newFace->planeChanged();
                }
        }
 }
 
+
 class FaceMakeBrush
 {
 const Brush& brush;
 brush_vector_t& out;
 float offset;
+bool room;
 public:
-FaceMakeBrush( const Brush& brush, brush_vector_t& out, float offset )
-       : brush( brush ), out( out ), offset( offset ){
+FaceMakeBrush( const Brush& brush, brush_vector_t& out, float offset, bool room )
+       : brush( brush ), out( out ), offset( offset ), room( room ){
 }
 void operator()( Face& face ) const {
-       Face_makeBrush( face, brush, out, offset );
+       if( room ){
+               Face_extrude( face, brush, out, offset );
+       }
+       else{
+               Face_makeBrush( face, brush, out, offset );
+       }
 }
 };
 
-void Brush_makeHollow( const Brush& brush, brush_vector_t& out, float offset ){
-       Brush_forEachFace( brush, FaceMakeBrush( brush, out, offset ) );
+void Brush_makeHollow( const Brush& brush, brush_vector_t& out, float offset, bool room ){
+       Brush_forEachFace( brush, FaceMakeBrush( brush, out, offset, room ) );
 }
 
 class BrushHollowSelectedWalker : public scene::Graph::Walker
 {
 float m_offset;
+bool room;
 public:
-BrushHollowSelectedWalker( float offset )
-       : m_offset( offset ){
+BrushHollowSelectedWalker( float offset, bool room )
+       : m_offset( offset ), room( room ){
 }
 bool pre( const scene::Path& path, scene::Instance& instance ) const {
        if ( path.top().get().visible() ) {
@@ -89,7 +97,7 @@ bool pre( const scene::Path& path, scene::Instance& instance ) const {
                         && Instance_getSelectable( instance )->isSelected()
                         && path.size() > 1 ) {
                        brush_vector_t out;
-                       Brush_makeHollow( *brush, out, m_offset );
+                       Brush_makeHollow( *brush, out, m_offset, room );
                        for ( brush_vector_t::const_iterator i = out.begin(); i != out.end(); ++i )
                        {
                                ( *i )->removeEmptyFaces();
@@ -143,8 +151,8 @@ void post( const scene::Path& path, scene::Instance& instance ) const {
 }
 };
 
-void Scene_BrushMakeHollow_Selected( scene::Graph& graph ){
-       GlobalSceneGraph().traverse( BrushHollowSelectedWalker( GetGridSize() ) );
+void Scene_BrushMakeHollow_Selected( scene::Graph& graph, bool room ){
+       GlobalSceneGraph().traverse( BrushHollowSelectedWalker( GetGridSize(), room ) );
        GlobalSceneGraph().traverse( BrushDeleteSelected() );
 }
 
@@ -157,7 +165,15 @@ void Scene_BrushMakeHollow_Selected( scene::Graph& graph ){
 void CSG_MakeHollow( void ){
        UndoableCommand undo( "brushHollow" );
 
-       Scene_BrushMakeHollow_Selected( GlobalSceneGraph() );
+       Scene_BrushMakeHollow_Selected( GlobalSceneGraph(), false );
+
+       SceneChangeNotify();
+}
+
+void CSG_MakeRoom( void ){
+       UndoableCommand undo( "makeRoom" );
+
+       Scene_BrushMakeHollow_Selected( GlobalSceneGraph(), true );
 
        SceneChangeNotify();
 }

diff --git a/radiant/csg.h b/radiant/csg.h
index 189ae72c3cb3988277624807d6a097d6b70aeabc..68e907c048216359a8c7ea134aeb909b5e1f8a84 100644 (file)
--- a/radiant/csg.h
+++ b/radiant/csg.h
@@ -23,6 +23,7 @@
 #define INCLUDED_CSG_H
 
 void CSG_MakeHollow( void );
+void CSG_MakeRoom( void );
 void CSG_Subtract( void );
 void CSG_Merge( void );
 

diff --git a/radiant/entityinspector.cpp b/radiant/entityinspector.cpp
index 5c1c330b913f7d6966550eb10dc7ff2db07741c3..407aaa1a000a76503b4dfd1aebcef777af252940 100644 (file)
--- a/radiant/entityinspector.cpp
+++ b/radiant/entityinspector.cpp
@@ -1170,6 +1170,23 @@ void EntityInspector_clearKeyValue(){
        }
 }
 
+static gint EntityInspector_clearKeyValueKB( GtkEntry* widget, GdkEventKey* event, gpointer data ){
+       if ( event->keyval == GDK_Delete ) {
+               // Get current selection text
+               StringOutputStream key( 64 );
+               key << gtk_entry_get_text( g_entityKeyEntry );
+
+               if ( strcmp( key.c_str(), "classname" ) != 0 ) {
+                       StringOutputStream command;
+                       command << "entityDeleteKey -key " << key.c_str();
+                       UndoableCommand undo( command.c_str() );
+                       Scene_EntitySetKeyValue_Selected( key.c_str(), "" );
+               }
+               return TRUE;
+       }
+       return FALSE;
+}
+
 void EntityInspector_clearAllKeyValues(){
        UndoableCommand undo( "entityClear" );
 
@@ -1285,8 +1302,19 @@ static gint EntityEntry_keypress( GtkEntry* widget, GdkEventKey* event, gpointer
                }
                return TRUE;
        }
+       if ( event->keyval == GDK_Tab ) {
+               if ( widget == g_entityKeyEntry ) {
+                       gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityValueEntry ) );
+               }
+               else
+               {
+                       gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityKeyEntry ) );
+               }
+               return TRUE;
+       }
        if ( event->keyval == GDK_Escape ) {
-               gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), NULL );
+               //gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), NULL );
+               GroupDialog_showPage( g_page_entity );
                return TRUE;
        }
 
@@ -1301,11 +1329,26 @@ void EntityInspector_destroyWindow( GtkWidget* widget, gpointer data ){
        GlobalEntityAttributes_clear();
 }
 
+static gint EntityInspector_destroyWindowKB( GtkWidget* widget, GdkEventKey* event, gpointer data ){
+       //if ( event->keyval == GDK_Escape && GTK_WIDGET_VISIBLE( GTK_WIDGET( widget ) ) ) {
+       if ( event->keyval == GDK_Escape  ) {
+               //globalErrorStream() << "Doom3Light_getBounds: failed to parse default light radius\n";
+               GroupDialog_showPage( g_page_entity );
+               return TRUE;
+       }
+       if ( event->keyval == GDK_Tab  ) {
+               gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( widget ) ) ), GTK_WIDGET( g_entityKeyEntry ) );
+               return TRUE;
+       }
+       return FALSE;
+}
+
 GtkWidget* EntityInspector_constructWindow( GtkWindow* toplevel ){
        GtkWidget* vbox = gtk_vbox_new( FALSE, 2 );
        gtk_widget_show( vbox );
        gtk_container_set_border_width( GTK_CONTAINER( vbox ), 2 );
 
+       g_signal_connect( G_OBJECT( toplevel ), "key_press_event", G_CALLBACK( EntityInspector_destroyWindowKB ), 0 );
        g_signal_connect( G_OBJECT( vbox ), "destroy", G_CALLBACK( EntityInspector_destroyWindow ), 0 );
 
        {
@@ -1420,6 +1463,7 @@ GtkWidget* EntityInspector_constructWindow( GtkWindow* toplevel ){
                                                GtkWidget* view = gtk_tree_view_new_with_model( GTK_TREE_MODEL( store ) );
                                                gtk_tree_view_set_enable_search( GTK_TREE_VIEW( view ), FALSE );
                                                gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( view ), FALSE );
+                                               g_signal_connect( G_OBJECT( view ), "key_press_event", G_CALLBACK( EntityInspector_clearKeyValueKB ), 0 );
 
                                                {
                                                        GtkCellRenderer* renderer = gtk_cell_renderer_text_new();

diff --git a/radiant/main.cpp b/radiant/main.cpp
index c669aba41f4d5367024720aa6ed6a2d2c9f04b11..addfd576fab0beac5a7f27216d325029ec850226 100644 (file)
--- a/radiant/main.cpp
+++ b/radiant/main.cpp
@@ -554,6 +554,7 @@ int main( int argc, char* argv[] ){
        if ( lib != 0 ) {
                void ( WINAPI *qDwmEnableComposition )( bool bEnable ) = ( void (WINAPI *) ( bool bEnable ) )GetProcAddress( lib, "DwmEnableComposition" );
                if ( qDwmEnableComposition ) {
+                       // disable Aero
                        qDwmEnableComposition( FALSE );
                }
                FreeLibrary( lib );

diff --git a/radiant/mainframe.cpp b/radiant/mainframe.cpp
index 6c4e1382966cc26c60581b3b5c7ade7b18478fff..4f0bfef048a272dae128eec9bb9041e509a404a6 100644 (file)
--- a/radiant/mainframe.cpp
+++ b/radiant/mainframe.cpp
@@ -2314,6 +2314,7 @@ void CSG_constructToolbar( GtkToolbar* toolbar ){
        toolbar_append_button( toolbar, "CSG Subtract (SHIFT + U)", "selection_csgsubtract.bmp", "CSGSubtract" );
        toolbar_append_button( toolbar, "CSG Merge (CTRL + U)", "selection_csgmerge.bmp", "CSGMerge" );
        toolbar_append_button( toolbar, "Hollow", "selection_makehollow.bmp", "CSGHollow" );
+       toolbar_append_button( toolbar, "Room", "selection_makeroom.bmp", "CSGroom" );
 }
 
 void ComponentModes_constructToolbar( GtkToolbar* toolbar ){
@@ -2841,42 +2842,35 @@ void MainFrame::Create(){
 
        if ( CurrentStyle() == eRegular || CurrentStyle() == eRegularLeft ) {
                {
-                       GtkWidget* vsplit = gtk_vpaned_new();
-                       m_vSplit = vsplit;
-                       gtk_box_pack_start( GTK_BOX( vbox ), vsplit, TRUE, TRUE, 0 );
-                       gtk_widget_show( vsplit );
-
-                       // console
-                       GtkWidget* console_window = Console_constructWindow( window );
-                       gtk_paned_pack2( GTK_PANED( vsplit ), console_window, FALSE, TRUE );
-
+                       GtkWidget* hsplit = gtk_hpaned_new();
+                       m_hSplit = hsplit;
+                       gtk_box_pack_start( GTK_BOX( vbox ), hsplit, TRUE, TRUE, 0 );
+                       gtk_widget_show( hsplit );
                        {
-                               GtkWidget* hsplit = gtk_hpaned_new();
-                               gtk_widget_show( hsplit );
-                               m_hSplit = hsplit;
-                               gtk_paned_add1( GTK_PANED( vsplit ), hsplit );
+                               GtkWidget* vsplit = gtk_vpaned_new();
+                               gtk_widget_show( vsplit );
+                               m_vSplit = vsplit;
+                               GtkWidget* vsplit2 = gtk_vpaned_new();
+                               gtk_widget_show( vsplit2 );
+                               m_vSplit2 = vsplit2;
+                               if ( CurrentStyle() == eRegular ){
+                                       gtk_paned_add1( GTK_PANED( hsplit ), vsplit );
+                                       gtk_paned_add2( GTK_PANED( hsplit ), vsplit2 );
+                               }
+                               else{
+                                       gtk_paned_add2( GTK_PANED( hsplit ), vsplit );
+                                       gtk_paned_add1( GTK_PANED( hsplit ), vsplit2 );
+                               }
+                               // console
+                               GtkWidget* console_window = Console_constructWindow( window );
+                               gtk_paned_pack2( GTK_PANED( vsplit ), console_window, FALSE, TRUE );
 
                                // xy
                                m_pXYWnd = new XYWnd();
                                m_pXYWnd->SetViewType( XY );
                                GtkWidget* xy_window = GTK_WIDGET( create_framed_widget( m_pXYWnd->GetWidget() ) );
-
+                               gtk_paned_add1( GTK_PANED( vsplit ), xy_window );
                                {
-                                       GtkWidget* vsplit2 = gtk_vpaned_new();
-                                       gtk_widget_show( vsplit2 );
-                                       m_vSplit2 = vsplit2;
-
-                                       if ( CurrentStyle() == eRegular ) {
-                                               gtk_paned_add1( GTK_PANED( hsplit ), xy_window );
-                                               gtk_paned_add2( GTK_PANED( hsplit ), vsplit2 );
-                                       }
-                                       else
-                                       {
-                                               gtk_paned_add1( GTK_PANED( hsplit ), vsplit2 );
-                                               gtk_paned_add2( GTK_PANED( hsplit ), xy_window );
-                                       }
-
-
                                        // camera
                                        m_pCamWnd = NewCamWnd();
                                        GlobalCamera_setCamWnd( *m_pCamWnd );
@@ -3317,6 +3311,7 @@ void MainFrame_Construct(){
        GlobalCommands_insert( "CSGSubtract", FreeCaller<CSG_Subtract>(), Accelerator( 'U', (GdkModifierType)GDK_SHIFT_MASK ) );
        GlobalCommands_insert( "CSGMerge", FreeCaller<CSG_Merge>(), Accelerator( 'U', (GdkModifierType)GDK_CONTROL_MASK ) );
        GlobalCommands_insert( "CSGHollow", FreeCaller<CSG_MakeHollow>() );
+       GlobalCommands_insert( "CSGroom", FreeCaller<CSG_MakeRoom>() );
 
        Grid_registerCommands();
 

diff --git a/radiant/preferences.cpp b/radiant/preferences.cpp
index a5538349a5cb7ea21928362b513605ea36ef4cfe..d93457c7122257b16da83909caf18007fe59cc85 100644 (file)
--- a/radiant/preferences.cpp
+++ b/radiant/preferences.cpp
@@ -87,6 +87,7 @@ void Mouse_constructPreferences( PreferencesPage& page ){
                page.appendRadio( "Mouse Type",  g_glwindow_globals.m_nMouseType, STRING_ARRAY_RANGE( buttons ) );
        }
        page.appendCheckBox( "Right Button", "Activates Context Menu", g_xywindow_globals.m_bRightClick );
+       page.appendCheckBox( "", "Improved mousewheel zoom", g_xywindow_globals.m_bImprovedWheelZoom );
 }
 void Mouse_constructPage( PreferenceGroup& group ){
        PreferencesPage page( group.createPage( "Mouse", "Mouse Preferences" ) );

diff --git a/radiant/select.cpp b/radiant/select.cpp
index 0728692ea895af4e9ca85e980cdb270696538dcb..4c9b30f9bdd6ae019e8183ec95c45767d95ee95a 100644 (file)
--- a/radiant/select.cpp
+++ b/radiant/select.cpp
@@ -894,6 +894,9 @@ struct RotateDialog
 static gboolean rotatedlg_apply( GtkWidget *widget, RotateDialog* rotateDialog ){
        Vector3 eulerXYZ;
 
+       gtk_spin_button_update ( rotateDialog->x );
+       gtk_spin_button_update ( rotateDialog->y );
+       gtk_spin_button_update ( rotateDialog->z );
        eulerXYZ[0] = static_cast<float>( gtk_spin_button_get_value( rotateDialog->x ) );
        eulerXYZ[1] = static_cast<float>( gtk_spin_button_get_value( rotateDialog->y ) );
        eulerXYZ[2] = static_cast<float>( gtk_spin_button_get_value( rotateDialog->z ) );
@@ -918,7 +921,8 @@ static gboolean rotatedlg_cancel( GtkWidget *widget, RotateDialog* rotateDialog
 
 static gboolean rotatedlg_ok( GtkWidget *widget, RotateDialog* rotateDialog ){
        rotatedlg_apply( widget, rotateDialog );
-       rotatedlg_cancel( widget, rotateDialog );
+//     rotatedlg_cancel( widget, rotateDialog );
+       gtk_widget_hide( GTK_WIDGET( rotateDialog->window ) );
        return TRUE;
 }
 
@@ -1070,7 +1074,8 @@ static gboolean scaledlg_cancel( GtkWidget *widget, ScaleDialog* scaleDialog ){
 
 static gboolean scaledlg_ok( GtkWidget *widget, ScaleDialog* scaleDialog ){
        scaledlg_apply( widget, scaleDialog );
-       scaledlg_cancel( widget, scaleDialog );
+       //scaledlg_cancel( widget, scaleDialog );
+       gtk_widget_hide( GTK_WIDGET( scaleDialog->window ) );
        return TRUE;
 }
 

diff --git a/radiant/texwindow.cpp b/radiant/texwindow.cpp
index 94717d0949bd75a9d9b913c62b72ef40ee42bdc3..c7e02c117a753303c690f69776db82561d8e0c21 100644 (file)
--- a/radiant/texwindow.cpp
+++ b/radiant/texwindow.cpp
@@ -132,7 +132,7 @@ typedef ReferenceCaller1<TextureGroups, const char*, TextureGroups_addDirectory>
 namespace
 {
 bool g_TextureBrowser_shaderlistOnly = false;
-bool g_TextureBrowser_fixedSize = false;
+bool g_TextureBrowser_fixedSize = true;
 bool g_TextureBrowser_filterNotex = false;
 }
 
@@ -264,40 +264,78 @@ bool m_searchedTags;
 bool m_tags;
 // The uniform size (in pixels) that textures are resized to when m_resizeTextures is true.
 int m_uniformTextureSize;
+int m_uniformTextureMinSize;
 // Return the display width of a texture in the texture browser
-int getTextureWidth( qtexture_t* tex ){
-       int width;
+/*void getTextureWH( qtexture_t* tex, int *width, int *height ){
        if ( !g_TextureBrowser_fixedSize ) {
                // Don't use uniform size
-               width = (int)( tex->width * ( (float)m_textureScale / 100 ) );
+               *width = (int)( tex->width * ( (float)m_textureScale / 100 ) );
+               *height = (int)( tex->height * ( (float)m_textureScale / 100 ) );
+
        }
-       else if
-       ( tex->width >= tex->height ) {
+       else if ( tex->width >= tex->height ) {
                // Texture is square, or wider than it is tall
-               width = m_uniformTextureSize;
+               if ( tex->width >= m_uniformTextureSize ){
+                       *width = m_uniformTextureSize;
+                       *height = (int)( m_uniformTextureSize * ( (float)tex->height / tex->width ) );
+               }
+               else if ( tex->width <= m_uniformTextureMinSize ){
+                       *width = m_uniformTextureMinSize;
+                       *height = (int)( m_uniformTextureMinSize * ( (float)tex->height / tex->width ) );
+               }
+               else {
+                       *width = tex->width;
+                       *height = tex->height;
+               }
        }
        else {
-               // Otherwise, preserve the texture's aspect ratio
-               width = (int)( m_uniformTextureSize * ( (float)tex->width / tex->height ) );
+               // Texture taller than it is wide
+               if ( tex->height >= m_uniformTextureSize ){
+                       *height = m_uniformTextureSize;
+                       *width = (int)( m_uniformTextureSize * ( (float)tex->width / tex->height ) );
+               }
+               else if ( tex->height <= m_uniformTextureMinSize ){
+                       *height = m_uniformTextureMinSize;
+                       *width = (int)( m_uniformTextureMinSize * ( (float)tex->width / tex->height ) );
+               }
+               else {
+                       *width = tex->width;
+                       *height = tex->height;
+               }
        }
-       return width;
 }
-// Return the display height of a texture in the texture browser
-int getTextureHeight( qtexture_t* tex ){
-       int height;
-       if ( !g_TextureBrowser_fixedSize ) {
+*/
+void getTextureWH( qtexture_t* tex, int *width, int *height ){
                // Don't use uniform size
-               height = (int)( tex->height * ( (float)m_textureScale / 100 ) );
-       }
-       else if ( tex->height >= tex->width ) {
-               // Texture is square, or taller than it is wide
-               height = m_uniformTextureSize;
-       }
-       else {
-               // Otherwise, preserve the texture's aspect ratio
-               height = (int)( m_uniformTextureSize * ( (float)tex->height / tex->width ) );
+               *width = (int)( tex->width * ( (float)m_textureScale / 100 ) );
+               *height = (int)( tex->height * ( (float)m_textureScale / 100 ) );
+
+       if ( g_TextureBrowser_fixedSize ){
+               int W = *width;
+               int H = *height;
+               if      ( W >= H ) {
+                       // Texture is square, or wider than it is tall
+                       if ( W >= m_uniformTextureSize ){
+                               *width = m_uniformTextureSize;
+                               *height = m_uniformTextureSize * H / W;
+                       }
+                       else if ( W <= m_uniformTextureMinSize ){
+                               *width = m_uniformTextureMinSize;
+                               *height = m_uniformTextureMinSize * H / W;
+                       }
+               }
+               else {
+                       // Texture taller than it is wide
+                       if ( H >= m_uniformTextureSize ){
+                               *height = m_uniformTextureSize;
+                               *width = m_uniformTextureSize * W / H;
+                       }
+                       else if ( H <= m_uniformTextureMinSize ){
+                               *height = m_uniformTextureMinSize;
+                               *width = m_uniformTextureMinSize * W / H;
+                       }
+               }
        }
-       return height;
 }
 
 TextureBrowser() :
@@ -320,7 +358,8 @@ TextureBrowser() :
        m_rmbSelected( false ),
        m_searchedTags( false ),
        m_tags( false ),
-       m_uniformTextureSize( 128 ){
+       m_uniformTextureSize( 160 ),
+       m_uniformTextureMinSize( 48 ){
 }
 };
 
@@ -421,8 +460,8 @@ void Texture_StartPos( TextureLayout& layout ){
 void Texture_NextPos( TextureBrowser& textureBrowser, TextureLayout& layout, qtexture_t* current_texture, int *x, int *y ){
        qtexture_t* q = current_texture;
 
-       int nWidth = textureBrowser.getTextureWidth( q );
-       int nHeight = textureBrowser.getTextureHeight( q );
+       int nWidth, nHeight;
+       textureBrowser.getTextureWH( q, &nWidth, &nHeight );
        if ( layout.current_x + nWidth > textureBrowser.width - 8 && layout.current_row ) { // go to the next row unless the texture is the first on the row
                layout.current_x = 8;
                layout.current_y -= layout.current_row + TextureBrowser_fontHeight( textureBrowser ) + 4;
@@ -534,7 +573,9 @@ void TextureBrowser_evaluateHeight( TextureBrowser& textureBrowser ){
 
                        int x, y;
                        Texture_NextPos( textureBrowser, layout, shader->getTexture(), &x, &y );
-                       textureBrowser.m_nTotalHeight = std::max( textureBrowser.m_nTotalHeight, abs( layout.current_y ) + TextureBrowser_fontHeight( textureBrowser ) + textureBrowser.getTextureHeight( shader->getTexture() ) + 4 );
+                       int nWidth, nHeight;
+                       textureBrowser.getTextureWH( shader->getTexture(), &nWidth, &nHeight );
+                       textureBrowser.m_nTotalHeight = std::max( textureBrowser.m_nTotalHeight, abs( layout.current_y ) + TextureBrowser_fontHeight( textureBrowser ) + nHeight + 4 );
                }
        }
 }
@@ -581,12 +622,15 @@ void TextureBrowser_addActiveShadersChangedCallback( const SignalHandler& handle
        g_activeShadersChangedCallbacks.connectLast( handler );
 }
 
+void TextureBrowser_constructTreeStore();
+
 class ShadersObserver : public ModuleObserver
 {
 Signal0 m_realiseCallbacks;
 public:
 void realise(){
        m_realiseCallbacks();
+       TextureBrowser_constructTreeStore();
 }
 void unrealise(){
 }
@@ -915,8 +959,8 @@ IShader* Texture_At( TextureBrowser& textureBrowser, int mx, int my ){
                        break;
                }
 
-               int nWidth = textureBrowser.getTextureWidth( q );
-               int nHeight = textureBrowser.getTextureHeight( q );
+               int nWidth, nHeight;
+               textureBrowser.getTextureWH( q, &nWidth, &nHeight );
                if ( mx > x && mx - x < nWidth
                         && my < y && y - my < nHeight + TextureBrowser_fontHeight( textureBrowser ) ) {
                        return shader;
@@ -1046,8 +1090,8 @@ void Texture_Draw( TextureBrowser& textureBrowser ){
                        break;
                }
 
-               int nWidth = textureBrowser.getTextureWidth( q );
-               int nHeight = textureBrowser.getTextureHeight( q );
+               int nWidth, nHeight;
+               textureBrowser.getTextureWH( q, &nWidth, &nHeight );
 
                if ( y != last_y ) {
                        last_y = y;
@@ -1167,6 +1211,15 @@ void TextureBrowser_setScale( TextureBrowser& textureBrowser, std::size_t scale
        TextureBrowser_queueDraw( textureBrowser );
 }
 
+void TextureBrowser_setUniformSize( TextureBrowser& textureBrowser, std::size_t scale ){
+       textureBrowser.m_uniformTextureSize = scale;
+       TextureBrowser_queueDraw( textureBrowser );
+}
+
+void TextureBrowser_setUniformMinSize( TextureBrowser& textureBrowser, std::size_t scale ){
+       textureBrowser.m_uniformTextureMinSize = scale;
+       TextureBrowser_queueDraw( textureBrowser );
+}
 
 void TextureBrowser_MouseWheel( TextureBrowser& textureBrowser, bool bUp ){
        int originy = TextureBrowser_getOriginY( textureBrowser );
@@ -1477,6 +1530,8 @@ void TreeView_onRowActivated( GtkTreeView* treeview, GtkTreePath* path, GtkTreeV
                ScopeDisableScreenUpdates disableScreenUpdates( dirName, "Loading Textures" );
                TextureBrowser_ShowDirectory( GlobalTextureBrowser(), dirName );
                TextureBrowser_queueDraw( GlobalTextureBrowser() );
+               //deactivate, so SPACE and RETURN wont be broken for 2d
+               gtk_window_set_focus( GTK_WINDOW( gtk_widget_get_toplevel( GTK_WIDGET( treeview ) ) ), NULL );
        }
 }
 
@@ -2429,6 +2484,18 @@ void TextureScaleExport( TextureBrowser& textureBrowser, const IntImportCallback
 }
 typedef ReferenceCaller1<TextureBrowser, const IntImportCallback&, TextureScaleExport> TextureScaleExportCaller;
 
+void UniformTextureSizeImport( TextureBrowser& textureBrowser, int value ){
+       if ( value >= 16 )
+               TextureBrowser_setUniformSize( textureBrowser, value );
+}
+typedef ReferenceCaller1<TextureBrowser, int, UniformTextureSizeImport> UniformTextureSizeImportCaller;
+
+void UniformTextureMinSizeImport( TextureBrowser& textureBrowser, int value ){
+       if ( value >= 16 )
+               TextureBrowser_setUniformMinSize( textureBrowser, value );
+}
+typedef ReferenceCaller1<TextureBrowser, int, UniformTextureMinSizeImport> UniformTextureMinSizeImportCaller;
+
 void TextureBrowser_constructPreferences( PreferencesPage& page ){
        page.appendCheckBox(
                "", "Texture scrollbar",
@@ -2444,6 +2511,8 @@ void TextureBrowser_constructPreferences( PreferencesPage& page ){
                        IntExportCallback( TextureScaleExportCaller( GlobalTextureBrowser() ) )
                        );
        }
+       page.appendSpinner( "Thumbnails Max Size", GlobalTextureBrowser().m_uniformTextureSize, GlobalTextureBrowser().m_uniformTextureSize, 16, 8192 );
+       page.appendSpinner( "Thumbnails Min Size", GlobalTextureBrowser().m_uniformTextureMinSize, GlobalTextureBrowser().m_uniformTextureMinSize, 16, 8192 );
        page.appendEntry( "Mousewheel Increment", GlobalTextureBrowser().m_mouseWheelScrollIncrement );
        {
                const char* startup_shaders[] = { "None", TextureBrowser_getComonShadersName() };
@@ -2489,6 +2558,12 @@ void TextureBrowser_Construct(){
                                                                                                 makeSizeStringImportCallback( TextureBrowserSetScaleCaller( g_TextureBrowser ) ),
                                                                                                 SizeExportStringCaller( g_TextureBrowser.m_textureScale )
                                                                                                 );
+       GlobalPreferenceSystem().registerPreference( "UniformTextureSize",
+                                                                                               makeIntStringImportCallback(UniformTextureSizeImportCaller(g_TextureBrowser)),
+                                                                                               IntExportStringCaller(g_TextureBrowser.m_uniformTextureSize) );
+       GlobalPreferenceSystem().registerPreference( "UniformTextureMinSize",
+                                                                                               makeIntStringImportCallback(UniformTextureMinSizeImportCaller(g_TextureBrowser)),
+                                                                                               IntExportStringCaller(g_TextureBrowser.m_uniformTextureMinSize) );
        GlobalPreferenceSystem().registerPreference( "TextureScrollbar",
                                                                                                 makeBoolStringImportCallback( TextureBrowserImportShowScrollbarCaller( g_TextureBrowser ) ),
                                                                                                 BoolExportStringCaller( GlobalTextureBrowser().m_showTextureScrollbar )

diff --git a/radiant/xywindow.cpp b/radiant/xywindow.cpp
index 471a5572a6d65d91e4c5022a4a445599a2a7df7f..b33243f7548b3fa7156b262043ae665d5e3ee7ac 100644 (file)
--- a/radiant/xywindow.cpp
+++ b/radiant/xywindow.cpp
@@ -493,17 +493,17 @@ void XYWnd::SetScale( float f ){
        XYWnd_Update( *this );
 }
 
-void XYWnd_ZoomIn( XYWnd* xy ){
+void XYWnd::ZoomIn(){
        float max_scale = 64;
-       float scale = xy->Scale() * 5.0f / 4.0f;
+       float scale = Scale() * 5.0f / 4.0f;
        if ( scale > max_scale ) {
-               if ( xy->Scale() != max_scale ) {
-                       xy->SetScale( max_scale );
+               if ( Scale() != max_scale ) {
+                       SetScale( max_scale );
                }
        }
        else
        {
-               xy->SetScale( scale );
+               SetScale( scale );
        }
 }
 
@@ -511,17 +511,31 @@ void XYWnd_ZoomIn( XYWnd* xy ){
 // NOTE: the zoom out factor is 4/5, we could think about customizing it
 //  we don't go below a zoom factor corresponding to 10% of the max world size
 //  (this has to be computed against the window size)
-void XYWnd_ZoomOut( XYWnd* xy ){
-       float min_scale = MIN( xy->Width(),xy->Height() ) / ( 1.1f * ( g_MaxWorldCoord - g_MinWorldCoord ) );
-       float scale = xy->Scale() * 4.0f / 5.0f;
+void XYWnd::ZoomOut(){
+       float min_scale = MIN( Width(), Height() ) / ( 1.1f * ( g_MaxWorldCoord - g_MinWorldCoord ) );
+       float scale = Scale() * 4.0f / 5.0f;
        if ( scale < min_scale ) {
-               if ( xy->Scale() != min_scale ) {
-                       xy->SetScale( min_scale );
+               if ( Scale() != min_scale ) {
+                       SetScale( min_scale );
                }
        }
        else
        {
-               xy->SetScale( scale );
+               SetScale( scale );
+       }
+}
+
+void XYWnd::ZoomInWithMouse( int pointx, int pointy ){
+       float old_scale = Scale();
+       ZoomIn();
+       if ( g_xywindow_globals.m_bImprovedWheelZoom ) {
+               float scale_diff = 1.0 / old_scale - 1.0 / Scale();
+               int nDim1 = ( m_viewType == YZ ) ? 1 : 0;
+               int nDim2 = ( m_viewType == XY ) ? 1 : 2;
+               Vector3 origin = GetOrigin();
+               origin[nDim1] += scale_diff * (pointx - 0.5 * Width());
+               origin[nDim2] -= scale_diff * (pointy - 0.5 * Height());
+               SetOrigin( origin );
        }
 }
 
@@ -748,10 +762,10 @@ void xywnd_motion( gdouble x, gdouble y, guint state, void* data ){
 
 gboolean xywnd_wheel_scroll( GtkWidget* widget, GdkEventScroll* event, XYWnd* xywnd ){
        if ( event->direction == GDK_SCROLL_UP ) {
-               XYWnd_ZoomIn( xywnd );
+               xywnd->ZoomInWithMouse( (int)event->x, (int)event->y );
        }
        else if ( event->direction == GDK_SCROLL_DOWN ) {
-               XYWnd_ZoomOut( xywnd );
+               xywnd->ZoomOut();
        }
        return FALSE;
 }
@@ -1201,16 +1215,15 @@ int g_dragZoom = 0;
 void XYWnd_zoomDelta( int x, int y, unsigned int state, void* data ){
        if ( y != 0 ) {
                g_dragZoom += y;
-
                while ( abs( g_dragZoom ) > 8 )
                {
                        if ( g_dragZoom > 0 ) {
-                               XYWnd_ZoomOut( reinterpret_cast<XYWnd*>( data ) );
+                               reinterpret_cast<XYWnd*>( data )->ZoomOut();
                                g_dragZoom -= 8;
                        }
                        else
                        {
-                               XYWnd_ZoomIn( reinterpret_cast<XYWnd*>( data ) );
+                               reinterpret_cast<XYWnd*>( data )->ZoomIn();
                                g_dragZoom += 8;
                        }
                }
@@ -2508,14 +2521,14 @@ void XY_Zoom100(){
 }
 
 void XY_ZoomIn(){
-       XYWnd_ZoomIn( g_pParentWnd->ActiveXY() );
+       g_pParentWnd->ActiveXY()->ZoomIn();
 }
 
 // NOTE: the zoom out factor is 4/5, we could think about customizing it
 //  we don't go below a zoom factor corresponding to 10% of the max world size
 //  (this has to be computed against the window size)
 void XY_ZoomOut(){
-       XYWnd_ZoomOut( g_pParentWnd->ActiveXY() );
+       g_pParentWnd->ActiveXY()->ZoomOut();
 }
 
 
@@ -2756,6 +2769,7 @@ void XYWindow_Construct(){
        GlobalPreferenceSystem().registerPreference( "ClipCaulk", BoolImportStringCaller( g_clip_useCaulk ), BoolExportStringCaller( g_clip_useCaulk ) );
 
        GlobalPreferenceSystem().registerPreference( "NewRightClick", BoolImportStringCaller( g_xywindow_globals.m_bRightClick ), BoolExportStringCaller( g_xywindow_globals.m_bRightClick ) );
+       GlobalPreferenceSystem().registerPreference( "ImprovedWheelZoom", BoolImportStringCaller( g_xywindow_globals.m_bImprovedWheelZoom ), BoolExportStringCaller( g_xywindow_globals.m_bImprovedWheelZoom ) );
        GlobalPreferenceSystem().registerPreference( "ChaseMouse", BoolImportStringCaller( g_xywindow_globals_private.m_bChaseMouse ), BoolExportStringCaller( g_xywindow_globals_private.m_bChaseMouse ) );
        GlobalPreferenceSystem().registerPreference( "SizePainting", BoolImportStringCaller( g_xywindow_globals_private.m_bSizePaint ), BoolExportStringCaller( g_xywindow_globals_private.m_bSizePaint ) );
        GlobalPreferenceSystem().registerPreference( "ShowCrosshair", BoolImportStringCaller( g_bCrossHairs ), BoolExportStringCaller( g_bCrossHairs ) );

diff --git a/radiant/xywindow.h b/radiant/xywindow.h
index 114f339486af1dce1c75c6f075fb4b58cfd08f54..a8b4aaa2206bca913a7dbfb8d8f5d0f8874e987b 100644 (file)
--- a/radiant/xywindow.h
+++ b/radiant/xywindow.h
@@ -126,6 +126,10 @@ void Zoom_End();
 bool m_zoom_started;
 guint m_zoom_focusOut;
 
+void ZoomIn();
+void ZoomOut();
+void ZoomInWithMouse( int pointx, int pointy );
+
 void SetActive( bool b ){
        m_bActive = b;
 };
@@ -253,6 +257,7 @@ struct xywindow_globals_t
 
        bool m_bRightClick;
        bool m_bNoStipple;
+       bool m_bImprovedWheelZoom;
 
        xywindow_globals_t() :
                color_gridback( 0.77f, 0.77f, 0.77f ),
@@ -271,7 +276,8 @@ struct xywindow_globals_t
                AxisColorY( 0.f, 1.f, 0.f ),
                AxisColorZ( 0.f, 0.f, 1.f ),
                m_bRightClick( true ),
-               m_bNoStipple( false ){
+               m_bNoStipple( false ),
+               m_bImprovedWheelZoom( true ){
        }
 
 };

diff --git a/setup/data/tools/bitmaps/selection_makehollow.bmp b/setup/data/tools/bitmaps/selection_makehollow.bmp
index 8c5d60cd5076a621c71cbe216b98aef3aa4b794e..d333e2e4bfef4d116f43627ef4ecb91ceeed5bff 100644 (file)
Binary files a/setup/data/tools/bitmaps/selection_makehollow.bmp and b/setup/data/tools/bitmaps/selection_makehollow.bmp differ

diff --git a/setup/data/tools/bitmaps/selection_makeroom.bmp b/setup/data/tools/bitmaps/selection_makeroom.bmp
new file mode 100644 (file)
index 0000000..1fcc788
Binary files /dev/null and b/setup/data/tools/bitmaps/selection_makeroom.bmp differ

diff --git a/tools/quake3/common/threads.c b/tools/quake3/common/threads.c
index 4d44bf36c8743ac9dd5a58f6c661f80a15dcee88..04946dd2f72edfc87566a954fee655d57becd854 100644 (file)
--- a/tools/quake3/common/threads.c
+++ b/tools/quake3/common/threads.c
@@ -538,7 +538,7 @@ void RunThreadsOn( int workcnt, qboolean showpacifier, void ( *func )( int ) ){
        size_t stacksize;
 
        int start, end;
-       int i = 0, status = 0;
+       int i = 0;
 
        start     = I_FloatTime();
        pacifier  = showpacifier;
@@ -582,7 +582,7 @@ void RunThreadsOn( int workcnt, qboolean showpacifier, void ( *func )( int ) ){
                }
                for ( i = 0 ; i < numthreads ; i++ )
                {
-                       if ( pthread_join( work_threads[i], (void **)&status ) != 0 ) {
+                       if ( pthread_join( work_threads[i], NULL ) != 0 ) {
                                Error( "pthread_join failed" );
                        }
                }

diff --git a/tools/quake3/q3map2/light.c b/tools/quake3/q3map2/light.c
index d724389ed0148b73b927fa61df37fb5876b6ab6a..9b3926e5fe02c82dafd9488c7cef223e607843f2 100644 (file)
--- a/tools/quake3/q3map2/light.c
+++ b/tools/quake3/q3map2/light.c
@@ -2403,6 +2403,30 @@ int LightMain( int argc, char **argv ){
                        i++;
                }
 
+               /* Lighting brightness */
+               else if( !strcmp( argv[ i ], "-brightness" ) ){
+                       f = atof( argv[ i + 1 ] );
+                       lightmapBrightness = f;
+                       Sys_Printf( "Lighting brightness set to %f\n", lightmapBrightness );
+                       i++;
+               }
+
+               /* Lighting contrast */
+               else if( !strcmp( argv[ i ], "-contrast" ) ){
+                       f = atof( argv[ i + 1 ] );
+                       lightmapContrast = f;
+                       if( lightmapContrast > 255 ){
+                               lightmapContrast = 255;
+                       }
+                       else if( lightmapContrast < -255 ){
+                               lightmapContrast = -255;
+                       }
+                       Sys_Printf( "Lighting contrast set to %f\n", lightmapContrast );
+                       i++;
+                       /* change to factor in range of 0 to 129.5 */
+                       lightmapContrast = ( 259 * ( lightmapContrast + 255 ) ) / ( 255 * ( 259 - lightmapContrast ) );
+               }
+
                /* ydnar switches */
                else if ( !strcmp( argv[ i ], "-bounce" ) ) {
                        bounce = atoi( argv[ i + 1 ] );

diff --git a/tools/quake3/q3map2/light_ydnar.c b/tools/quake3/q3map2/light_ydnar.c
index df53d7edd42382968d3ace7f9b080478b3f160e9..4aa7eac7d8b9913b2630a401bb1af6bf9b47fe68 100644 (file)
--- a/tools/quake3/q3map2/light_ydnar.c
+++ b/tools/quake3/q3map2/light_ydnar.c
@@ -55,6 +55,8 @@ void ColorToBytes( const float *color, byte *colorBytes, float scale ){
        if ( scale <= 0.0f ) {
                scale = 1.0f;
        }
+       /* globally */
+       scale *= lightmapBrightness;
 
        /* make a local copy */
        VectorScale( color, scale, sample );
@@ -119,6 +121,23 @@ void ColorToBytes( const float *color, byte *colorBytes, float scale ){
        /* compensate for ingame overbrighting/bitshifting */
        VectorScale( sample, ( 1.0f / lightmapCompensate ), sample );
 
+       /* contrast */
+       if ( lightmapContrast != 1.0f ){
+               for ( i = 0; i < 3; i++ ){
+                       sample[i] = lightmapContrast * ( sample[i] - 128 ) + 128;
+                       if ( sample[i] < 0 ){
+                               sample[i] = 0;
+                       }
+               }
+               if ( ( sample[0] > 255 ) || ( sample[1] > 255 ) || ( sample[2] > 255 ) ) {
+                       max = sample[0] > sample[1] ? sample[0] : sample[1];
+                       max = max > sample[2] ? max : sample[2];
+                       sample[0] = sample[0] * 255 / max;
+                       sample[1] = sample[1] * 255 / max;
+                       sample[2] = sample[2] * 255 / max;
+               }
+       }
+
        /* sRGB lightmaps */
        if ( lightmapsRGB ) {
                sample[0] = floor( Image_sRGBFloatFromLinearFloat( sample[0] * ( 1.0 / 255.0 ) ) * 255.0 + 0.5 );

diff --git a/tools/quake3/q3map2/main.c b/tools/quake3/q3map2/main.c
index 550a57dacd339000423cfbdedd28c1cbaea0e7eb..9841b4f177ab0524951fd724458c61275985f0e7 100644 (file)
--- a/tools/quake3/q3map2/main.c
+++ b/tools/quake3/q3map2/main.c
@@ -2117,6 +2117,7 @@ skipEXfile:
                                                temp, scriptline, token );
                        }
 
+                       qboolean hasmap = qfalse;
                        while ( 1 )
                        {
                                /* get the next token */
@@ -2142,13 +2143,19 @@ skipEXfile:
                                                if ( !strcmp( token, "}" ) ) {
                                                        break;
                                                }
+                                               if ( !strcmp( token, "{" ) ) {
+                                                       Sys_Printf( "WARNING9: %s : line %d : opening brace inside shader stage\n", temp, scriptline );
+                                               }
+                                               if ( !stricmp( token, "mapComp" ) || !stricmp( token, "mapNoComp" ) || !stricmp( token, "animmapcomp" ) || !stricmp( token, "animmapnocomp" ) ){
+                                                       Sys_Printf( "WARNING7: %s : line %d : unsupported '%s' map directive\n", temp, scriptline, token );
+                                               }
                                                /* skip the shader */
                                                if ( !wantShader ) continue;
 
                                                /* digest any images */
                                                if ( !stricmp( token, "map" ) ||
                                                        !stricmp( token, "clampMap" ) ) {
-
+                                                       hasmap = qtrue;
                                                        /* get an image */
                                                        GetToken( qfalse );
                                                        if ( token[ 0 ] != '*' && token[ 0 ] != '$' ) {
@@ -2157,6 +2164,7 @@ skipEXfile:
                                                }
                                                else if ( !stricmp( token, "animMap" ) ||
                                                        !stricmp( token, "clampAnimMap" ) ) {
+                                                       hasmap = qtrue;
                                                        GetToken( qfalse );// skip num
                                                        while ( TokenAvailable() ){
                                                                GetToken( qfalse );
@@ -2164,6 +2172,7 @@ skipEXfile:
                                                        }
                                                }
                                                else if ( !stricmp( token, "videoMap" ) ){
+                                                       hasmap = qtrue;
                                                        GetToken( qfalse );
                                                        FixDOSName( token );
                                                        if ( strchr( token, '/' ) == NULL && strchr( token, '\\' ) == NULL ){
@@ -2188,6 +2197,9 @@ skipEXfile:
                                                }
                                        }
                                }
+                               else if ( !strnicmp( token, "implicit", 8 ) ){
+                                       Sys_Printf( "WARNING5: %s : line %d : unsupported %s shader\n", temp, scriptline, token );
+                               }
                                /* skip the shader */
                                else if ( !wantShader ) continue;
 
@@ -2206,6 +2218,7 @@ skipEXfile:
 
                                /* skyparms <outer image> <cloud height> <inner image> */
                                else if ( !stricmp( token, "skyParms" ) ) {
+                                       hasmap = qtrue;
                                        /* get image base */
                                        GetToken( qfalse );
 
@@ -2229,6 +2242,9 @@ skipEXfile:
                                        GetToken( qfalse );
                                        GetToken( qfalse );
                                }
+                               else if ( !stricmp( token, "fogparms" ) ){
+                                       hasmap = qtrue;
+                               }
                        }
 
                        //exclude shader
@@ -2240,6 +2256,9 @@ skipEXfile:
                                                break;
                                        }
                                }
+                               if ( !hasmap ){
+                                       wantShader = qfalse;
+                               }
                                if ( wantShader ){
                                        if ( ShaderFileExcluded ){
                                                if ( reasonShaderFile != NULL ){
@@ -2456,7 +2475,7 @@ skipEXfile:
 
 /*
    repackBSPMain()
-   repack multiple maps, strip only required shaders
+   repack multiple maps, strip out only required shaders
    works for Q3 type of shaders and ents
  */
 
@@ -3074,6 +3093,10 @@ skipEXrefile:
                                                        strcat( shaderText, "\n\t}" );
                                                        break;
                                                }
+                                               if ( !strcmp( token, "{" ) ) {
+                                                       strcat( shaderText, "\n\t{" );
+                                                       Sys_Printf( "WARNING9: %s : line %d : opening brace inside shader stage\n", temp, scriptline );
+                                               }
                                                /* skip the shader */
                                                if ( !wantShader ) continue;
 
@@ -3248,11 +3271,6 @@ skipEXrefile:
                        }
 
                        //exclude shader
-                       if ( wantShader && !hasmap ){
-                               Sys_Printf( "WARNING8: %s : shader has no known maps\n", pk3Shaders + shader*65 );
-                               wantShader = qfalse;
-                               *( pk3Shaders + shader*65 ) = '\0';
-                       }
                        if ( wantShader ){
                                for ( j = 0; j < ExShadersN; j++ ){
                                        if ( !stricmp( ExShaders + j*65, pk3Shaders + shader*65 ) ){
@@ -3261,6 +3279,11 @@ skipEXrefile:
                                                break;
                                        }
                                }
+                               if ( wantShader && !hasmap ){
+                                       Sys_Printf( "WARNING8: %s : shader has no known maps\n", pk3Shaders + shader*65 );
+                                       wantShader = qfalse;
+                                       *( pk3Shaders + shader*65 ) = '\0';
+                               }
                                if ( wantShader ){
                                        strcat( allShaders, shaderText );
                                        *( pk3Shaders + shader*65 ) = '\0';

diff --git a/tools/quake3/q3map2/model.c b/tools/quake3/q3map2/model.c
index e8e00d331c663d07bb4065303caa575409b635ff..c7f0a6b83251f62dc93d499025d653798dd44ea4 100644 (file)
--- a/tools/quake3/q3map2/model.c
+++ b/tools/quake3/q3map2/model.c
@@ -550,7 +550,7 @@ void InsertModel( const char *name, int skin, int frame, m4x4_t transform, remap
                        vec3_t min = { 999999, 999999, 999999 }, max = { -999999, -999999, -999999 };
                        vec3_t avgDirection = { 0, 0, 0 };
                        int axis;
-                       #define nonax_clip_dbg 1
+                       #define nonax_clip_dbg 0
 
                        /* temp hack */
                        if ( !si->clipModel && !( si->compileFlags & C_SOLID ) ) {

diff --git a/tools/quake3/q3map2/q3map2.h b/tools/quake3/q3map2/q3map2.h
index 36233d9d24afa3af992337c108a8610538d8c73c..df44fc84f7c9c56994359d75ab7d1b27d43dba40 100644 (file)
--- a/tools/quake3/q3map2/q3map2.h
+++ b/tools/quake3/q3map2/q3map2.h
@@ -2330,6 +2330,8 @@ Q_EXTERN float texturesRGB Q_ASSIGN( qfalse );
 Q_EXTERN float colorsRGB Q_ASSIGN( qfalse );
 Q_EXTERN float lightmapExposure Q_ASSIGN( 0.0f );
 Q_EXTERN float lightmapCompensate Q_ASSIGN( 1.0f );
+Q_EXTERN float lightmapBrightness Q_ASSIGN( 1.0f );
+Q_EXTERN float lightmapContrast Q_ASSIGN( 1.0f );
 
 /* ydnar: for runtime tweaking of falloff tolerance */
 Q_EXTERN float falloffTolerance Q_ASSIGN( 1.0f );