Group import/export callbacks

[xonotic/netradiant.git] / radiant / textures.cpp

diff --git a/radiant/textures.cpp b/radiant/textures.cpp
index b223e2ee1318a87c40d0b7ccbab788f13a72f1c1..eb98984620a3b71f669947b538ae823c891fc2d4 100644 (file)
--- a/radiant/textures.cpp
+++ b/radiant/textures.cpp
@@ -166,7 +166,7 @@ inline const int& min_int( const int& left, const int& right ){
 
 int max_tex_size = 0;
 const int max_texture_quality = 3;
-LatchedInt g_Textures_textureQuality( 3, "Texture Quality" );
+LatchedValue<int> g_Textures_textureQuality( 3, "Texture Quality" );
 
 /// \brief This function does the actual processing of raw RGBA data into a GL texture.
 /// It will also resample to power-of-two dimensions, generate the mipmaps and adjust gamma.
@@ -409,6 +409,7 @@ TexturesCacheObserver* m_observer;
 std::size_t m_unrealised;
 
 public:
+virtual ~TexturesMap() = default;
 TexturesMap() : m_qtextures( TextureConstructor( this ) ), m_observer( 0 ), m_unrealised( 1 ){
 }
 typedef qtextures_t::iterator iterator;
@@ -548,9 +549,9 @@ void Textures_Unrealise(){
 }
 
 
-Callback g_texturesModeChangedNotify;
+Callback<void()> g_texturesModeChangedNotify;
 
-void Textures_setModeChangedNotify( const Callback& notify ){
+void Textures_setModeChangedNotify( const Callback<void()>& notify ){
        g_texturesModeChangedNotify = notify;
 }
 
@@ -646,7 +647,7 @@ void TextureCompressionImport( TextureCompressionFormat& self, int value ){
        }
        Textures_UpdateTextureCompressionFormat();
 }
-typedef ReferenceCaller1<TextureCompressionFormat, int, TextureCompressionImport> TextureCompressionImportCaller;
+typedef ReferenceCaller<TextureCompressionFormat, void(int), TextureCompressionImport> TextureCompressionImportCaller;
 
 void TextureGammaImport( float& self, float value ){
        if ( self != value ) {
@@ -655,7 +656,7 @@ void TextureGammaImport( float& self, float value ){
                Textures_Realise();
        }
 }
-typedef ReferenceCaller1<float, float, TextureGammaImport> TextureGammaImportCaller;
+typedef ReferenceCaller<float, void(float), TextureGammaImport> TextureGammaImportCaller;
 
 void TextureModeImport( ETexturesMode& self, int value ){
        switch ( value )
@@ -682,9 +683,9 @@ void TextureModeImport( ETexturesMode& self, int value ){
                Textures_SetMode( eTextures_MAX_ANISOTROPY );
        }
 }
-typedef ReferenceCaller1<ETexturesMode, int, TextureModeImport> TextureModeImportCaller;
+typedef ReferenceCaller<ETexturesMode, void(int), TextureModeImport> TextureModeImportCaller;
 
-void TextureModeExport( ETexturesMode& self, const IntImportCallback& importer ){
+void TextureModeExport( ETexturesMode& self, const ImportExportCallback<int>::Import_t& importer ){
        switch ( self )
        {
        case eTextures_NEAREST:
@@ -712,7 +713,7 @@ void TextureModeExport( ETexturesMode& self, const IntImportCallback& importer )
                importer( 4 );
        }
 }
-typedef ReferenceCaller1<ETexturesMode, const IntImportCallback&, TextureModeExport> TextureModeExportCaller;
+typedef ReferenceCaller<ETexturesMode, void(const ImportExportCallback<int>::Import_t&), TextureModeExport> TextureModeExportCaller;
 
 void Textures_constructPreferences( PreferencesPage& page ){
        {
@@ -720,8 +721,7 @@ void Textures_constructPreferences( PreferencesPage& page ){
                page.appendRadio(
                        "Texture Quality",
                        STRING_ARRAY_RANGE( percentages ),
-                       LatchedIntImportCaller( g_Textures_textureQuality ),
-                       IntExportCaller( g_Textures_textureQuality.m_latched )
+                       mkImportExportCallback( g_Textures_textureQuality )
                        );
        }
        page.appendSpinner(
@@ -729,16 +729,16 @@ void Textures_constructPreferences( PreferencesPage& page ){
                1.0,
                0.0,
                1.0,
-               FloatImportCallback( TextureGammaImportCaller( g_texture_globals.fGamma ) ),
-               FloatExportCallback( FloatExportCaller( g_texture_globals.fGamma ) )
+               {ImportExportCallback<float>::Import_t( TextureGammaImportCaller( g_texture_globals.fGamma ) ),
+               ImportExportCallback<float>::Export_t( FloatExportCaller( g_texture_globals.fGamma ) )}
                );
        {
                const char* texture_mode[] = { "Nearest", "Nearest Mipmap", "Linear", "Bilinear", "Bilinear Mipmap", "Trilinear", "Anisotropy" };
                page.appendCombo(
                        "Texture Render Mode",
                        STRING_ARRAY_RANGE( texture_mode ),
-                       IntImportCallback( TextureModeImportCaller( g_texture_mode ) ),
-                       IntExportCallback( TextureModeExportCaller( g_texture_mode ) )
+                       {ImportExportCallback<int>::Import_t( TextureModeImportCaller( g_texture_mode ) ),
+                       ImportExportCallback<int>::Export_t( TextureModeExportCaller( g_texture_mode ) )}
                        );
        }
        {
@@ -758,8 +758,8 @@ void Textures_constructPreferences( PreferencesPage& page ){
                page.appendCombo(
                        "Hardware Texture Compression",
                        compression,
-                       TextureCompressionImportCaller( g_texture_globals.m_nTextureCompressionFormat ),
-                       IntExportCaller( reinterpret_cast<int&>( g_texture_globals.m_nTextureCompressionFormat ) )
+                       {TextureCompressionImportCaller( g_texture_globals.m_nTextureCompressionFormat ),
+                       IntExportCaller( reinterpret_cast<int&>( g_texture_globals.m_nTextureCompressionFormat ) )}
                        );
        }
 }
@@ -768,14 +768,14 @@ void Textures_constructPage( PreferenceGroup& group ){
        Textures_constructPreferences( page );
 }
 void Textures_registerPreferencesPage(){
-       PreferencesDialog_addDisplayPage( FreeCaller1<PreferenceGroup&, Textures_constructPage>() );
+       PreferencesDialog_addDisplayPage( makeCallbackF(Textures_constructPage) );
 }
 
 void TextureCompression_importString( const char* string ){
        g_texture_globals.m_nTextureCompressionFormat = static_cast<TextureCompressionFormat>( atoi( string ) );
        Textures_UpdateTextureCompressionFormat();
 }
-typedef FreeCaller1<const char*, TextureCompression_importString> TextureCompressionImportStringCaller;
+typedef FreeCaller<void(const char*), TextureCompression_importString> TextureCompressionImportStringCaller;
 
 
 void Textures_Construct(){