file(WRITE "${PROJECT_BINARY_DIR}/RADIANT_MAJOR" ${NetRadiant_VERSION_MAJOR})
file(WRITE "${PROJECT_BINARY_DIR}/RADIANT_MINOR" ${NetRadiant_VERSION_MINOR})
+file(WRITE "${PROJECT_BINARY_DIR}/RADIANT_PATCH" ${NetRadiant_VERSION_PATCH})
set(RADIANT_ABOUTMSG "Custom build" CACHE STRING "About message")
add_definitions(-DRADIANT_VERSION="${NetRadiant_VERSION}")
add_definitions(-DRADIANT_MAJOR_VERSION="${NetRadiant_VERSION_MAJOR}")
add_definitions(-DRADIANT_MINOR_VERSION="${NetRadiant_VERSION_MINOR}")
+add_definitions(-DRADIANT_PATCH_VERSION="${NetRadiant_VERSION_PATCH}")
add_definitions(-DRADIANT_ABOUTMSG="${NetRadiant_ABOUT}")
endif
# VERSION!
-RADIANT_VERSION_NUMBER = 1.5.0
+RADIANT_MAJOR_VERSION = 1
+RADIANT_MINOR_VERSION = 5
+RADIANT_PATCH_VERSION = 0
+RADIANT_VERSION_NUMBER = $(RADIANT_MAJOR_VERSION).$(RADIANT_MINOR_VERSION).$(RADIANT_PATCH_VERSION)
RADIANT_VERSION = $(RADIANT_VERSION_NUMBER)n
-RADIANT_MAJOR_VERSION = 5
-RADIANT_MINOR_VERSION = 0
Q3MAP_VERSION = 2.5.17n
# Executable extension
Q3MAP_VERSION := $(Q3MAP_VERSION)-git-$(GIT_VERSION)
endif
-CPPFLAGS += -DRADIANT_VERSION="\"$(RADIANT_VERSION)\"" -DRADIANT_MAJOR_VERSION="\"$(RADIANT_MAJOR_VERSION)\"" -DRADIANT_MINOR_VERSION="\"$(RADIANT_MINOR_VERSION)\"" -DRADIANT_ABOUTMSG="\"$(RADIANT_ABOUTMSG)\"" -DQ3MAP_VERSION="\"$(Q3MAP_VERSION)\"" -DRADIANT_EXECUTABLE="\"$(RADIANT_EXECUTABLE)\""
+CPPFLAGS += -DRADIANT_VERSION="\"$(RADIANT_VERSION)\"" -DRADIANT_MAJOR_VERSION="\"$(RADIANT_MAJOR_VERSION)\"" -DRADIANT_MINOR_VERSION="\"$(RADIANT_MINOR_VERSION)\"" -DRADIANT_PATCH_VERSION="\"$(RADIANT_PATCH_VERSION)\"" -DRADIANT_ABOUTMSG="\"$(RADIANT_ABOUTMSG)\"" -DQ3MAP_VERSION="\"$(Q3MAP_VERSION)\"" -DRADIANT_EXECUTABLE="\"$(RADIANT_EXECUTABLE)\""
.PHONY: all
all: \
$(MKDIR) $(INSTALLDIR)/games
$(FIND) $(INSTALLDIR_BASE)/ -name .svn -exec $(RM_R) {} \; -prune
DOWNLOAD_GAMEPACKS="$(DOWNLOAD_GAMEPACKS)" GIT="$(GIT)" SVN="$(SVN)" WGET="$(WGET)" RM_R="$(RM_R)" MV="$(MV)" UNZIPPER="$(UNZIPPER)" ECHO="$(ECHO)" SH="$(SH)" CP="$(CP)" CP_R="$(CP_R)" $(SH) install-gamepacks.sh "$(INSTALLDIR)"
- $(ECHO) $(RADIANT_MINOR_VERSION) > $(INSTALLDIR)/RADIANT_MINOR
$(ECHO) $(RADIANT_MAJOR_VERSION) > $(INSTALLDIR)/RADIANT_MAJOR
+ $(ECHO) $(RADIANT_MINOR_VERSION) > $(INSTALLDIR)/RADIANT_MINOR
+ $(ECHO) $(RADIANT_PATCH_VERSION) > $(INSTALLDIR)/RADIANT_PATCH
$(CP_R) setup/data/tools/* $(INSTALLDIR)/
$(MKDIR) $(INSTALLDIR)/docs
$(CP_R) docs/* $(INSTALLDIR)/docs/
add_library(includes
aboutmsg.h
cullable.cpp cullable.h
+ dpkdeps.h
editable.cpp editable.h
iarchive.cpp iarchive.h
ibrush.cpp ibrush.h
--- /dev/null
+#ifndef __DPKDEPS_H__
+#define __DPKDEPS_H__
+
+#include <locale>
+#include "string/string.h"
+
+// Comparaison function for version numbers
+// Implementation is based on dpkg's version comparison code (verrevcmp() and order())
+// http://anonscm.debian.org/gitweb/?p=dpkg/dpkg.git;a=blob;f=lib/dpkg/version.c;hb=74946af470550a3295e00cf57eca1747215b9311
+inline int char_weight(char c){
+ if (std::isdigit(c))
+ return 0;
+ else if (std::isalpha(c))
+ return c;
+ else if (c == '~')
+ return -1;
+ else if (c)
+ return c + 256;
+ else
+ return 0;
+}
+
+inline int DpkPakVersionCmp(const char* a, const char* b){
+ while (*a || *b) {
+ int firstDiff = 0;
+
+ while ((*a && !std::isdigit(*a)) || (*b && !std::isdigit(*b))) {
+ int ac = char_weight(*a);
+ int bc = char_weight(*b);
+
+ if (ac != bc)
+ return ac - bc;
+
+ a++;
+ b++;
+ }
+
+ while (*a == '0')
+ a++;
+ while (*b == '0')
+ b++;
+
+ while (std::isdigit(*a) && std::isdigit(*b)) {
+ if (firstDiff == 0)
+ firstDiff = *a - *b;
+ a++;
+ b++;
+ }
+
+ if (std::isdigit(*a))
+ return 1;
+ if (std::isdigit(*b))
+ return -1;
+ if (firstDiff)
+ return firstDiff;
+ }
+
+ return false;
+}
+
+// release strings after using
+inline bool DpkReadDepsLine( const char *line, char **pakname, char **pakversion ){
+ const char* c = line;
+ const char* p_name;
+ const char* p_name_end;
+ const char* p_version;
+ const char* p_version_end;
+
+ *pakname = 0;
+ *pakversion = 0;
+
+ while ( std::isspace( *c ) && *c != '\0' ) ++c;
+ p_name = c;
+ while ( !std::isspace( *c ) && *c != '\0' ) ++c;
+ p_name_end = c;
+ while ( std::isspace( *c ) && *c != '\0' ) ++c;
+ p_version = c;
+ while ( !std::isspace( *c ) && *c != '\0' ) ++c;
+ p_version_end = c;
+
+ if ( p_name_end - p_name > 0 ){
+ *pakname = string_clone_range( StringRange( p_name, p_name_end ) );
+ } else return false;
+
+ if ( p_version_end - p_version > 0 ) {
+ *pakversion = string_clone_range( StringRange( p_version, p_version_end ) );
+ }
+ return true;
+}
+
+#endif
#ifndef RADIANT_MINOR_VERSION
#error no RADIANT_MINOR_VERSION defined
#endif
+#ifndef RADIANT_PATCH_VERSION
+#error no RADIANT_PATCH_VERSION defined
+#endif
#include "os/path.h"
#include "moduleobservers.h"
#include "filematch.h"
+#include "dpkdeps.h"
#define VFS_MAXDIRS 64
g_pakfile_paths.insert( PakfilePathsKV( name, pakfile_path ) );
}
-// Comparaison function for version numbers
-// Implementation is based on dpkg's version comparison code (verrevcmp() and order())
-// http://anonscm.debian.org/gitweb/?p=dpkg/dpkg.git;a=blob;f=lib/dpkg/version.c;hb=74946af470550a3295e00cf57eca1747215b9311
-static int char_weight(char c){
- if (std::isdigit(c))
- return 0;
- else if (std::isalpha(c))
- return c;
- else if (c == '~')
- return -1;
- else if (c)
- return c + 256;
- else
- return 0;
-}
-
-static int VersionCmp(const char* a, const char* b){
- while (*a || *b) {
- int firstDiff = 0;
-
- while ((*a && !std::isdigit(*a)) || (*b && !std::isdigit(*b))) {
- int ac = char_weight(*a);
- int bc = char_weight(*b);
-
- if (ac != bc)
- return ac - bc;
-
- a++;
- b++;
- }
-
- while (*a == '0')
- a++;
- while (*b == '0')
- b++;
-
- while (std::isdigit(*a) && std::isdigit(*b)) {
- if (firstDiff == 0)
- firstDiff = *a - *b;
- a++;
- b++;
- }
-
- if (std::isdigit(*a))
- return 1;
- if (std::isdigit(*b))
- return -1;
- if (firstDiff)
- return firstDiff;
- }
-
- return false;
-}
-
// takes name without ext, returns without ext
static const char* GetLatestDpkPakVersion( const char* name ){
const char* maxversion = 0;
pakname = i->first.c_str();
if ( strncmp( pakname, name, namelen ) != 0 || pakname[namelen] != '_' ) continue;
pakversion = pakname + (namelen + 1);
- if ( maxversion == 0 || VersionCmp( pakversion, maxversion ) > 0 ){
+ if ( maxversion == 0 || DpkPakVersionCmp( pakversion, maxversion ) > 0 ){
maxversion = pakversion;
result = pakname;
}
TextLinesInputStream<TextInputStream> istream = depsFile->getInputStream();
CopiedString line;
- const char* c;
- const char* p_name;
- const char* p_name_end;
- const char* p_version;
- const char* p_version_end;
+ char *p_name;
+ char *p_version;
while ( line = istream.readLine(), string_length( line.c_str() ) ) {
- c = line.c_str();
- while ( std::isspace( *c ) && *c != '\0' ) ++c;
- p_name = c;
- while ( !std::isspace( *c ) && *c != '\0' ) ++c;
- p_name_end = c;
- while ( std::isspace( *c ) && *c != '\0' ) ++c;
- p_version = c;
- while ( !std::isspace( *c ) && *c != '\0' ) ++c;
- p_version_end = c;
-
- if ( p_name_end - p_name == 0 ) continue;
- if ( p_version_end - p_version == 0 ) {
- const char* p_pakname;
- CopiedString name_final = CopiedString( StringRange( p_name, p_name_end ) );
- p_pakname = GetLatestDpkPakVersion( name_final.c_str() );
- if ( p_pakname != NULL ) {
- LoadDpkPakWithDeps( p_pakname );
- }
+ if ( !DpkReadDepsLine( line.c_str(), &p_name, &p_version ) ) continue;
+ if ( !p_version ) {
+ const char* p_latest = GetLatestDpkPakVersion( p_name );
+ if ( p_latest ) LoadDpkPakWithDeps( p_latest );
} else {
- int len = ( p_name_end - p_name ) + ( p_version_end - p_version ) + 1;
+ int len = string_length( p_name ) + string_length( p_version ) + 1;
char* p_pakname = string_new( len );
- strncpy( p_pakname, p_name, p_name_end - p_name );
- p_pakname[ p_name_end - p_name ] = '\0';
- strcat( p_pakname, "_" );
- strncat( p_pakname, p_version, p_version_end - p_version );
+ sprintf( p_pakname, "%s_%s", p_name, p_version );
LoadDpkPakWithDeps( p_pakname );
string_release( p_pakname, len );
}
+ string_release( p_name, string_length( p_name ) );
+ if ( p_version ) string_release( p_version, string_length( p_version ) );
}
}
if ( !portable_app_setup() ) {
StringOutputStream home( 256 );
- home << DirectoryCleaned( g_get_home_dir() ) << ".netradiant/";
+ home << DirectoryCleaned( g_get_user_config_dir() ) << "netradiant/";
Q_mkdir( home.c_str() );
home_path = home.c_str();
}
{
StringOutputStream path( 256 );
- path << home << "1." << RADIANT_MAJOR_VERSION "." << RADIANT_MINOR_VERSION << '/';
+ path << home << "/";
g_strSettingsPath = path.c_str();
}
}
#endif
+ static GOptionEntry entries[] = {
+ { NULL }
+ };
+ GError *error = NULL;
+ const char* mapname = NULL;
+
gtk_disable_setlocale();
- gtk_init( &argc, &argv );
+ if ( !gtk_init_with_args( &argc, &argv, "<filename.map>", entries, NULL, &error) ) {
+ g_print( "%s\n", error->message );
+ return -1;
+ }
+
+ // Gtk already removed parsed `--options`
+ if (argc == 2) {
+ if ( strlen( argv[1] ) > 1 ) {
+ if ( g_str_has_suffix( argv[1], ".map" ) ) {
+ if ( g_path_is_absolute( argv[1] ) ) {
+ mapname = argv[1];
+ }
+ else {
+ mapname = g_build_filename( g_get_current_dir(), argv[1], NULL );
+ }
+ }
+ else {
+ g_print( "bad file name, will not load: %s\n", argv[1] );
+ }
+ }
+ }
+ else if (argc > 2) {
+ g_print ( "%s\n", "too many arguments" );
+ return -1;
+ }
// redirect Gtk warnings to the console
g_log_set_handler( "Gdk", (GLogLevelFlags)( G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING |
hide_splash();
- if ( g_bLoadLastMap && !g_strLastMap.empty() ) {
+ if ( mapname != NULL ) {
+ Map_LoadFile( mapname );
+ }
+ else if ( g_bLoadLastMap && !g_strLastMap.empty() ) {
Map_LoadFile( g_strLastMap.c_str() );
}
else
#include "renderstate.h"
#include "feedback.h"
#include "referencecache.h"
-
+#include "texwindow.h"
struct layout_globals_t
QE_InitVFS();
GlobalFileSystem().refresh();
g_vfsInitialized = true;
+ // also refresh texture browser
+ TextureBrowser_RefreshShaders();
}
void VFS_Restart(){
VFS_Shutdown();
#include "ifilesystem.h"
#include "namespace.h"
#include "moduleobserver.h"
-#include "moduleobservers.h"
#include <set>
#include "xywindow.h"
#include "mainframe.h"
#include "preferences.h"
+#include "preferencesystem.h"
#include "referencecache.h"
#include "mru.h"
#include "commands.h"
void AddRegionBrushes( void );
void RemoveRegionBrushes( void );
-/* Map open/close observers */
-
-ModuleObservers g_mapPathObservers;
-
-class MapFileObserver : public ModuleObserver
-{
-void realise() {
- // Refresh VFS to apply new pak filtering based on mapname
- // needed for daemon dpk vfs
- VFS_Refresh();
-}
-void unrealise() { }
-};
-
-MapFileObserver g_mapFileObserver;
-
-void BindMapFileObservers(){
- g_mapPathObservers.attach( g_mapFileObserver );
-}
-
-void UnBindMapFileObservers(){
- g_mapPathObservers.detach( g_mapFileObserver );
-}
/*
g_currentMap = 0;
Brush_unlatchPreferences();
- g_mapPathObservers.unrealise();
}
class EntityFindByClassname : public scene::Graph::Walker
}
};
+CopiedString g_strLastFolder = "";
+
/*
================
Map_LoadFile
globalOutputStream() << "Loading map from " << filename << "\n";
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" );
+ MRU_AddFile( filename );
+ g_strLastFolder = g_path_get_dirname( filename );
+
{
ScopeTimer timer( "map load" );
}
Brush_toggleFormat( i );
g_map.m_name = filename;
- g_mapPathObservers.realise();
Map_UpdateTitle( g_map );
g_map.m_resource = GlobalReferenceCache().capture( g_map.m_name.c_str() );
if ( format ) {
Map_StartPosition();
g_currentMap = &g_map;
+
+ // restart VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Restart();
}
class Excluder
g_map.m_resource->detach( g_map );
GlobalReferenceCache().release( g_map.m_name.c_str() );
- g_mapPathObservers.unrealise();
g_map.m_resource = resource;
g_map.m_name = absolute;
- g_mapPathObservers.realise();
Map_UpdateTitle( g_map );
g_map.m_resource->attach( g_map );
+ // refresh VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Refresh();
}
void Map_Rename( const char* filename ){
//globalOutputStream() << "Map_New\n";
g_map.m_name = "unnamed.map";
- g_mapPathObservers.realise();
Map_UpdateTitle( g_map );
{
FocusViews( g_vector3_identity, 0 );
g_currentMap = &g_map;
+
+ // restart VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Restart();
}
extern void ConstructRegionBrushes( scene::Node * brushes[6], const Vector3 ®ion_mins, const Vector3 ®ion_maxs );
bool Map_ImportFile( const char* filename ){
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Map" );
+ g_strLastFolder = g_path_get_dirname( filename );
+
bool success = false;
if ( extension_equal( path_get_extension( filename ), "bsp" ) ) {
*/
bool Map_SaveFile( const char* filename ){
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Saving Map" );
- return MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse, filename );
+ bool success = MapResource_saveFile( MapFormat_forFile( filename ), GlobalSceneGraph().root(), Map_Traverse, filename );
+ if ( success ) {
+ // refresh VFS to apply new pak filtering based on mapname
+ // needed for daemon DPK VFS
+ VFS_Refresh();
+ }
+ return success;
}
//
return g_mapsPath.c_str();
}
+const char* getLastFolderPath(){
+ if (g_strLastFolder.empty()) {
+ GlobalPreferenceSystem().registerPreference( "LastFolder", CopiedStringImportStringCaller( g_strLastFolder ), CopiedStringExportStringCaller( g_strLastFolder ) );
+ if (g_strLastFolder.empty()) {
+ g_strLastFolder = g_qeglobals.m_userGamePath;
+ }
+ }
+ return g_strLastFolder.c_str();
+}
+
const char* map_open( const char* title ){
- return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), TRUE, title, getMapsPath(), MapFormat::Name(), true, false, false );
+ return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), TRUE, title, getLastFolderPath(), MapFormat::Name(), false, true, false );
}
const char* map_import( const char* title ){
- return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), TRUE, title, getMapsPath(), MapFormat::Name(), false, true, false );
+ return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), TRUE, title, getLastFolderPath(), MapFormat::Name(), false, true, false );
}
const char* map_save( const char* title ){
- return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), FALSE, title, getMapsPath(), MapFormat::Name(), false, false, true );
+ return file_dialog( GTK_WIDGET( MainFrame_getWindow() ), FALSE, title, getLastFolderPath(), MapFormat::Name(), false, false, true );
}
void OpenMap(){
const char* filename = map_open( "Open Map" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
MRU_AddFile( filename );
Map_RegionOff();
Map_Free();
void ImportMap(){
const char* filename = map_import( "Import Map" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
UndoableCommand undo( "mapImport" );
Map_ImportFile( filename );
}
bool Map_SaveAs(){
const char* filename = map_save( "Save Map" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
+ g_strLastFolder = g_path_get_dirname( filename );
MRU_AddFile( filename );
Map_Rename( filename );
return Map_Save();
void ExportMap(){
const char* filename = map_save( "Export Selection" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
+ g_strLastFolder = g_path_get_dirname( filename );
Map_SaveSelected( filename );
}
}
void SaveRegion(){
const char* filename = map_save( "Export Region" );
- if ( filename != 0 ) {
+ if ( filename != NULL ) {
+ g_strLastFolder = g_path_get_dirname( filename );
Map_SaveRegion( filename );
}
}
MapModuleObserver g_MapModuleObserver;
-#include "preferencesystem.h"
-
CopiedString g_strLastMap;
bool g_bLoadLastMap = false;
const char* getMapsPath();
-void BindMapFileObservers();
-void UnBindMapFileObservers();
-
#endif
MapRoot_construct();
EnginePath_verify();
- BindMapFileObservers();
EnginePath_Realise();
}
~Radiant(){
EnginePath_Unrealise();
- UnBindMapFileObservers();
MapRoot_destroy();
NullModel_destroy();
#include "shaders.h"
#include "commands.h"
+#define NOTEX_BASENAME "notex"
+#define SHADERNOTEX_BASENAME "shadernotex"
+
bool TextureBrowser_showWads(){
return !string_empty( g_pGameDescription->getKeyValue( "show_wads" ) );
}
}
typedef ReferenceCaller1<TextureGroups, const char*, TextureGroups_addWad> TextureGroupsAddWadCaller;
+namespace
+{
+bool g_TextureBrowser_shaderlistOnly = false;
+bool g_TextureBrowser_fixedSize = true;
+bool g_TextureBrowser_filterMissing = false;
+bool g_TextureBrowser_filterFallback = true;
+bool g_TextureBrowser_enableAlpha = true;
+}
+
+CopiedString g_notex;
+CopiedString g_shadernotex;
+bool isMissing(const char* name);
+bool isNotex(const char* name);
+
+bool isMissing(const char* name){
+ if ( string_equal( g_notex.c_str(), name ) ) {
+ return true;
+ }
+ if ( string_equal( g_shadernotex.c_str(), name ) ) {
+ return true;
+ }
+ return false;
+}
+
+bool isNotex(const char* name){
+ if ( string_equal_suffix( name, "/" NOTEX_BASENAME ) ) {
+ return true;
+ }
+ if ( string_equal_suffix( name, "/" SHADERNOTEX_BASENAME ) ) {
+ return true;
+ }
+ return false;
+}
+
void TextureGroups_addShader( TextureGroups& groups, const char* shaderName ){
const char* texture = path_make_relative( shaderName, "textures/" );
+
+ // hide notex / shadernotex images
+ if ( g_TextureBrowser_filterFallback ) {
+ if ( isNotex( shaderName ) ) {
+ return;
+ }
+ if ( isNotex( texture ) ) {
+ return;
+ }
+ }
+
if ( texture != shaderName ) {
const char* last = path_remove_directory( texture );
if ( !string_empty( last ) ) {
}
typedef ReferenceCaller1<TextureGroups, const char*, TextureGroups_addDirectory> TextureGroupsAddDirectoryCaller;
-namespace
-{
-bool g_TextureBrowser_shaderlistOnly = false;
-bool g_TextureBrowser_fixedSize = true;
-bool g_TextureBrowser_filterNotex = false;
-bool g_TextureBrowser_enableAlpha = true;
-}
-
class DeferredAdjustment
{
gdouble m_value;
void TextureBrowser_fixedSize( const BoolImportCallback& importer );
typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_fixedSize> TextureBrowserFixedSizeExport;
-void TextureBrowser_filterNotex( const BoolImportCallback& importer );
-typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_filterNotex> TextureBrowserFilterNotexExport;
+void TextureBrowser_filterMissing( const BoolImportCallback& importer );
+typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_filterMissing> TextureBrowserFilterMissingExport;
+
+void TextureBrowser_filterFallback( const BoolImportCallback& importer );
+typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_filterFallback> TextureBrowserFilterFallbackExport;
void TextureBrowser_enableAlpha( const BoolImportCallback& importer );
typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_enableAlpha> TextureBrowserEnableAlphaExport;
std::set<CopiedString> m_found_shaders;
ToggleItem m_hideunused_item;
+ToggleItem m_hidenotex_item;
ToggleItem m_showshaders_item;
ToggleItem m_showshaderlistonly_item;
ToggleItem m_fixedsize_item;
m_showshaders_item( TextureBrowserShowShadersExport() ),
m_showshaderlistonly_item( TextureBrowserShowShaderlistOnlyExport() ),
m_fixedsize_item( TextureBrowserFixedSizeExport() ),
- m_filternotex_item( TextureBrowserFilterNotexExport() ),
+ m_filternotex_item( TextureBrowserFilterMissingExport() ),
+ m_hidenotex_item( TextureBrowserFilterFallbackExport() ),
m_enablealpha_item( TextureBrowserEnableAlphaExport() ),
m_heightChanged( true ),
m_originInvalid( true ),
}
}
-CopiedString g_notex;
-CopiedString g_shadernotex;
-
// if texture_showinuse jump over non in-use textures
bool Texture_IsShown( IShader* shader, bool show_shaders, bool hideUnused ){
- // filter notex / shadernotex images
- if ( g_TextureBrowser_filterNotex && ( string_equal( g_notex.c_str(), shader->getTexture()->name ) || string_equal( g_shadernotex.c_str(), shader->getTexture()->name ) ) ) {
- return false;
+ // filter missing shaders
+ // ugly: filter on built-in fallback name after substitution
+ if ( g_TextureBrowser_filterMissing ) {
+ if ( isMissing( shader->getTexture()->name ) ) {
+ return false;
+ }
+ }
+ // filter the fallback (notex/shadernotex) for missing shaders or editor image
+ if ( g_TextureBrowser_filterFallback ) {
+ if ( isNotex( shader->getName() ) ) {
+ return false;
+ }
+ if ( isNotex( shader->getTexture()->name ) ) {
+ return false;
+ }
}
if ( g_TextureBrowser_currentDirectory == "Untagged" ) {
}
typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_fixedSize> TextureBrowser_FixedSizeExport;
-void TextureBrowser_filterNotex( const BoolImportCallback& importer ){
- importer( g_TextureBrowser_filterNotex );
+void TextureBrowser_filterMissing( const BoolImportCallback& importer ){
+ importer( g_TextureBrowser_filterMissing );
}
-typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_filterNotex> TextureBrowser_filterNotexExport;
+typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_filterMissing> TextureBrowser_filterMissingExport;
+
+void TextureBrowser_filterFallback( const BoolImportCallback& importer ){
+ importer( g_TextureBrowser_filterFallback );
+}
+typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_filterFallback> TextureBrowser_filterFallbackExport;
void TextureBrowser_enableAlpha( const BoolImportCallback& importer ){
importer( g_TextureBrowser_enableAlpha );
create_check_menu_item_with_mnemonic( menu, "Hide _Unused", "ShowInUse" );
if ( string_empty( g_pGameDescription->getKeyValue( "show_wads" ) ) ) {
- create_check_menu_item_with_mnemonic( menu, "Hide Image Missing", "FilterNotex" );
+ create_check_menu_item_with_mnemonic( menu, "Hide Image Missing", "FilterMissing" );
}
+
+ // hide notex and shadernotex on texture browser: no one wants to apply them
+ create_check_menu_item_with_mnemonic( menu, "Hide Fallback", "FilterFallback" );
+
menu_separator( menu );
create_menu_item_with_mnemonic( menu, "Show All", "ShowAllTextures" );
void TextureBrowser_SetNotex(){
StringOutputStream name( 256 );
- name << GlobalRadiant().getAppPath() << "bitmaps/notex.png";
+ name << GlobalRadiant().getAppPath() << "bitmaps/" NOTEX_BASENAME ".png";
g_notex = name.c_str();
name = NULL;
- name << GlobalRadiant().getAppPath() << "bitmaps/shadernotex.png";
+ name << GlobalRadiant().getAppPath() << "bitmaps/" SHADERNOTEX_BASENAME " .png";
g_shadernotex = name.c_str();
}
BuildStoreAvailableTags( g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store, g_TextureBrowser.m_all_tags, &g_TextureBrowser );
}
-void RefreshShaders(){
+void TextureBrowser_RefreshShaders(){
ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Shaders" );
- VFS_Refresh();
GlobalShaderSystem().refresh();
UpdateAllWindows();
GtkTreeSelection* selection = gtk_tree_view_get_selection((GtkTreeView*)GlobalTextureBrowser().m_treeViewTree);
TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
}
-void TextureBrowser_FilterNotex(){
- g_TextureBrowser_filterNotex ^= 1;
+void TextureBrowser_FilterMissing(){
+ g_TextureBrowser_filterMissing ^= 1;
GlobalTextureBrowser().m_filternotex_item.update();
TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
+ TextureBrowser_RefreshShaders();
+}
+
+void TextureBrowser_FilterFallback(){
+ g_TextureBrowser_filterFallback ^= 1;
+ GlobalTextureBrowser().m_hidenotex_item.update();
+ TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
+ TextureBrowser_RefreshShaders();
}
void TextureBrowser_EnableAlpha(){
GlobalCommands_insert( "DeleteTag", FreeCaller<TextureBrowser_deleteTag>() );
GlobalCommands_insert( "CopyTag", FreeCaller<TextureBrowser_copyTag>() );
GlobalCommands_insert( "PasteTag", FreeCaller<TextureBrowser_pasteTag>() );
- GlobalCommands_insert( "RefreshShaders", FreeCaller<RefreshShaders>() );
+ GlobalCommands_insert( "RefreshShaders", FreeCaller<VFS_Refresh>() );
GlobalToggles_insert( "ShowInUse", FreeCaller<TextureBrowser_ToggleHideUnused>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_hideunused_item ), Accelerator( 'U' ) );
GlobalCommands_insert( "ShowAllTextures", FreeCaller<TextureBrowser_showAll>(), Accelerator( 'A', (GdkModifierType)GDK_CONTROL_MASK ) );
GlobalCommands_insert( "ToggleTextures", FreeCaller<TextureBrowser_toggleShow>(), Accelerator( 'T' ) );
GlobalToggles_insert( "ToggleShowShaders", FreeCaller<TextureBrowser_ToggleShowShaders>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_showshaders_item ) );
GlobalToggles_insert( "ToggleShowShaderlistOnly", FreeCaller<TextureBrowser_ToggleShowShaderListOnly>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_showshaderlistonly_item ) );
GlobalToggles_insert( "FixedSize", FreeCaller<TextureBrowser_FixedSize>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_fixedsize_item ) );
- GlobalToggles_insert( "FilterNotex", FreeCaller<TextureBrowser_FilterNotex>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_filternotex_item ) );
+ GlobalToggles_insert( "FilterMissing", FreeCaller<TextureBrowser_FilterMissing>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_filternotex_item ) );
+ GlobalToggles_insert( "FilterFallback", FreeCaller<TextureBrowser_FilterFallback>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_hidenotex_item ) );
GlobalToggles_insert( "EnableAlpha", FreeCaller<TextureBrowser_EnableAlpha>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_enablealpha_item ) );
GlobalPreferenceSystem().registerPreference( "TextureScale",
GlobalPreferenceSystem().registerPreference( "ShowShaders", BoolImportStringCaller( GlobalTextureBrowser().m_showShaders ), BoolExportStringCaller( GlobalTextureBrowser().m_showShaders ) );
GlobalPreferenceSystem().registerPreference( "ShowShaderlistOnly", BoolImportStringCaller( g_TextureBrowser_shaderlistOnly ), BoolExportStringCaller( g_TextureBrowser_shaderlistOnly ) );
GlobalPreferenceSystem().registerPreference( "FixedSize", BoolImportStringCaller( g_TextureBrowser_fixedSize ), BoolExportStringCaller( g_TextureBrowser_fixedSize ) );
- GlobalPreferenceSystem().registerPreference( "FilterNotex", BoolImportStringCaller( g_TextureBrowser_filterNotex ), BoolExportStringCaller( g_TextureBrowser_filterNotex ) );
+ GlobalPreferenceSystem().registerPreference( "FilterMissing", BoolImportStringCaller( g_TextureBrowser_filterMissing ), BoolExportStringCaller( g_TextureBrowser_filterMissing ) );
GlobalPreferenceSystem().registerPreference( "EnableAlpha", BoolImportStringCaller( g_TextureBrowser_enableAlpha ), BoolExportStringCaller( g_TextureBrowser_enableAlpha ) );
GlobalPreferenceSystem().registerPreference( "LoadShaders", IntImportStringCaller( reinterpret_cast<int&>( GlobalTextureBrowser().m_startupShaders ) ), IntExportStringCaller( reinterpret_cast<int&>( GlobalTextureBrowser().m_startupShaders ) ) );
GlobalPreferenceSystem().registerPreference( "WheelMouseInc", SizeImportStringCaller( GlobalTextureBrowser().m_mouseWheelScrollIncrement ), SizeExportStringCaller( GlobalTextureBrowser().m_mouseWheelScrollIncrement ) );
void TextureBrowser_addActiveShadersChangedCallback( const SignalHandler& handler );
void TextureBrowser_addShadersRealiseCallback( const SignalHandler& handler );
+void TextureBrowser_RefreshShaders();
+
#endif
projects / xonotic / netradiant.git / commitdiff