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.
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;
}
-Callback g_texturesModeChangedNotify;
+Callback<void()> g_texturesModeChangedNotify;
-void Textures_setModeChangedNotify( const Callback& notify ){
+void Textures_setModeChangedNotify( const Callback<void()>& notify ){
g_texturesModeChangedNotify = notify;
}
Textures_setTextureComponents( texture_components );
}
-void TextureCompressionImport( TextureCompressionFormat& self, int value ){
- if ( !g_texture_globals.m_bOpenGLCompressionSupported
- && g_texture_globals.m_bS3CompressionSupported
- && value >= 1 ) {
- ++value;
- }
- switch ( value )
- {
- case 0:
- self = TEXTURECOMPRESSION_NONE;
- break;
- case 1:
- self = TEXTURECOMPRESSION_RGBA;
- break;
- case 2:
- self = TEXTURECOMPRESSION_RGBA_S3TC_DXT1;
- break;
- case 3:
- self = TEXTURECOMPRESSION_RGBA_S3TC_DXT3;
- break;
- case 4:
- self = TEXTURECOMPRESSION_RGBA_S3TC_DXT5;
- break;
- }
- Textures_UpdateTextureCompressionFormat();
-}
-typedef ReferenceCaller1<TextureCompressionFormat, int, TextureCompressionImport> TextureCompressionImportCaller;
+struct TextureCompression {
+ static void Export(const TextureCompressionFormat &self, const Callback<void(int)> &returnz) {
+ returnz(self);
+ }
+
+ static void Import(TextureCompressionFormat &self, int value) {
+ if (!g_texture_globals.m_bOpenGLCompressionSupported
+ && g_texture_globals.m_bS3CompressionSupported
+ && value >= 1) {
+ ++value;
+ }
+ switch (value) {
+ case 0:
+ self = TEXTURECOMPRESSION_NONE;
+ break;
+ case 1:
+ self = TEXTURECOMPRESSION_RGBA;
+ break;
+ case 2:
+ self = TEXTURECOMPRESSION_RGBA_S3TC_DXT1;
+ break;
+ case 3:
+ self = TEXTURECOMPRESSION_RGBA_S3TC_DXT3;
+ break;
+ case 4:
+ self = TEXTURECOMPRESSION_RGBA_S3TC_DXT5;
+ break;
+ }
+ Textures_UpdateTextureCompressionFormat();
+ }
+};
-void TextureGammaImport( float& self, float value ){
- if ( self != value ) {
- Textures_Unrealise();
- self = value;
- Textures_Realise();
+struct TextureGamma {
+ static void Export(const float &self, const Callback<void(float)> &returnz) {
+ returnz(self);
}
-}
-typedef ReferenceCaller1<float, float, TextureGammaImport> TextureGammaImportCaller;
-void TextureModeImport( ETexturesMode& self, int value ){
- switch ( value )
- {
- case 0:
- Textures_SetMode( eTextures_NEAREST );
- break;
- case 1:
- Textures_SetMode( eTextures_NEAREST_MIPMAP_NEAREST );
- break;
- case 2:
- Textures_SetMode( eTextures_LINEAR );
- break;
- case 3:
- Textures_SetMode( eTextures_NEAREST_MIPMAP_LINEAR );
- break;
- case 4:
- Textures_SetMode( eTextures_LINEAR_MIPMAP_NEAREST );
- break;
- case 5:
- Textures_SetMode( eTextures_LINEAR_MIPMAP_LINEAR );
- break;
- case 6:
- Textures_SetMode( eTextures_MAX_ANISOTROPY );
+ static void Import(float &self, float value) {
+ if (value != self) {
+ Textures_Unrealise();
+ self = value;
+ Textures_Realise();
+ }
}
-}
-typedef ReferenceCaller1<ETexturesMode, int, TextureModeImport> TextureModeImportCaller;
+};
-void TextureModeExport( ETexturesMode& self, const IntImportCallback& importer ){
- switch ( self )
- {
- case eTextures_NEAREST:
- importer( 0 );
- break;
- case eTextures_NEAREST_MIPMAP_NEAREST:
- importer( 1 );
- break;
- case eTextures_LINEAR:
- importer( 2 );
- break;
- case eTextures_NEAREST_MIPMAP_LINEAR:
- importer( 3 );
- break;
- case eTextures_LINEAR_MIPMAP_NEAREST:
- importer( 4 );
- break;
- case eTextures_LINEAR_MIPMAP_LINEAR:
- importer( 5 );
- break;
- case eTextures_MAX_ANISOTROPY:
- importer( 6 );
- break;
- default:
- importer( 4 );
- }
-}
-typedef ReferenceCaller1<ETexturesMode, const IntImportCallback&, TextureModeExport> TextureModeExportCaller;
+struct TextureMode {
+ static void Export(const ETexturesMode &self, const Callback<void(int)> &returnz) {
+ switch (self) {
+ case eTextures_NEAREST:
+ returnz(0);
+ break;
+ case eTextures_NEAREST_MIPMAP_NEAREST:
+ returnz(1);
+ break;
+ case eTextures_LINEAR:
+ returnz(2);
+ break;
+ case eTextures_NEAREST_MIPMAP_LINEAR:
+ returnz(3);
+ break;
+ case eTextures_LINEAR_MIPMAP_NEAREST:
+ returnz(4);
+ break;
+ case eTextures_LINEAR_MIPMAP_LINEAR:
+ returnz(5);
+ break;
+ case eTextures_MAX_ANISOTROPY:
+ returnz(6);
+ break;
+ default:
+ returnz(4);
+ }
+ }
+
+ static void Import(ETexturesMode &self, int value) {
+ switch (value) {
+ case 0:
+ Textures_SetMode(eTextures_NEAREST);
+ break;
+ case 1:
+ Textures_SetMode(eTextures_NEAREST_MIPMAP_NEAREST);
+ break;
+ case 2:
+ Textures_SetMode(eTextures_LINEAR);
+ break;
+ case 3:
+ Textures_SetMode(eTextures_NEAREST_MIPMAP_LINEAR);
+ break;
+ case 4:
+ Textures_SetMode(eTextures_LINEAR_MIPMAP_NEAREST);
+ break;
+ case 5:
+ Textures_SetMode(eTextures_LINEAR_MIPMAP_LINEAR);
+ break;
+ case 6:
+ Textures_SetMode(eTextures_MAX_ANISOTROPY);
+ }
+ }
+};
void Textures_constructPreferences( PreferencesPage& page ){
{
page.appendRadio(
"Texture Quality",
STRING_ARRAY_RANGE( percentages ),
- LatchedIntImportCaller( g_Textures_textureQuality ),
- IntExportCaller( g_Textures_textureQuality.m_latched )
+ make_property( g_Textures_textureQuality )
);
}
page.appendSpinner(
1.0,
0.0,
1.0,
- FloatImportCallback( TextureGammaImportCaller( g_texture_globals.fGamma ) ),
- FloatExportCallback( FloatExportCaller( g_texture_globals.fGamma ) )
+ make_property<TextureGamma>(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 ) )
+ make_property<TextureMode>(g_texture_mode)
);
}
{
page.appendCombo(
"Hardware Texture Compression",
compression,
- TextureCompressionImportCaller( g_texture_globals.m_nTextureCompressionFormat ),
- IntExportCaller( reinterpret_cast<int&>( g_texture_globals.m_nTextureCompressionFormat ) )
+ make_property<TextureCompression>(g_texture_globals.m_nTextureCompressionFormat)
);
}
}
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;
+struct TextureCompressionPreference {
+ static void Export(const Callback<void(int)> &returnz) {
+ returnz(g_texture_globals.m_nTextureCompressionFormat);
+ }
+ static void Import(int value) {
+ g_texture_globals.m_nTextureCompressionFormat = static_cast<TextureCompressionFormat>( value );
+ Textures_UpdateTextureCompressionFormat();
+ }
+};
void Textures_Construct(){
g_texturesmap = new TexturesMap;
- GlobalPreferenceSystem().registerPreference( "TextureCompressionFormat", TextureCompressionImportStringCaller(), IntExportStringCaller( reinterpret_cast<int&>( g_texture_globals.m_nTextureCompressionFormat ) ) );
- GlobalPreferenceSystem().registerPreference( "TextureFiltering", IntImportStringCaller( reinterpret_cast<int&>( g_texture_mode ) ), IntExportStringCaller( reinterpret_cast<int&>( g_texture_mode ) ) );
- GlobalPreferenceSystem().registerPreference( "TextureQuality", IntImportStringCaller( g_Textures_textureQuality.m_latched ), IntExportStringCaller( g_Textures_textureQuality.m_latched ) );
- GlobalPreferenceSystem().registerPreference( "SI_Gamma", FloatImportStringCaller( g_texture_globals.fGamma ), FloatExportStringCaller( g_texture_globals.fGamma ) );
+ GlobalPreferenceSystem().registerPreference( "TextureCompressionFormat", make_property_string<TextureCompressionPreference>() );
+ GlobalPreferenceSystem().registerPreference( "TextureFiltering", make_property_string( reinterpret_cast<int&>( g_texture_mode ) ) );
+ GlobalPreferenceSystem().registerPreference( "TextureQuality", make_property_string( g_Textures_textureQuality.m_latched ) );
+ GlobalPreferenceSystem().registerPreference( "SI_Gamma", make_property_string( g_texture_globals.fGamma ) );
g_Textures_textureQuality.useLatched();
public GlobalPreferenceSystemModuleRef
{
ImageModulesRef m_image_modules;
+ImageModulesRef m_fallback_image_modules;
public:
TexturesDependencies() :
- m_image_modules( GlobalRadiant().getRequiredGameDescriptionKeyValue( "texturetypes" ) ){
+ m_image_modules( GlobalRadiant().getRequiredGameDescriptionKeyValue( "texturetypes" ) ),
+ m_fallback_image_modules( "png" ){
}
ImageModules& getImageModules(){
return m_image_modules.get();
}
+ImageModules& getFallbackImageModules(){
+ return m_fallback_image_modules.get();
+}
};
class TexturesAPI
ImageModules& Textures_getImageModules(){
return StaticTexturesModule::instance().getDependencies().getImageModules();
}
+ImageModules& Textures_getFallbackImageModules(){
+ return StaticTexturesModule::instance().getDependencies().getFallbackImageModules();
+}
projects / xonotic / netradiant.git / blobdiff