-/*\r
-Copyright (c) 2001, Loki software, inc.\r
-All rights reserved.\r
-\r
-Redistribution and use in source and binary forms, with or without modification, \r
-are permitted provided that the following conditions are met:\r
-\r
-Redistributions of source code must retain the above copyright notice, this list \r
-of conditions and the following disclaimer.\r
-\r
-Redistributions in binary form must reproduce the above copyright notice, this\r
-list of conditions and the following disclaimer in the documentation and/or\r
-other materials provided with the distribution.\r
-\r
-Neither the name of Loki software nor the names of its contributors may be used \r
-to endorse or promote products derived from this software without specific prior \r
-written permission. \r
-\r
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' \r
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE \r
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE \r
-DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY \r
-DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES \r
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; \r
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON \r
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT \r
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS \r
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. \r
-*/\r
-\r
-#include "stdafx.h"\r
-\r
-bfilter_t *FilterAdd(bfilter_t *pFilter, int type, int bmask, char *str, int exclude)\r
-{\r
- bfilter_t *pNew = new bfilter_t;\r
- pNew->next = pFilter;\r
- pNew->attribute = type;\r
- if (type == 1 || type == 3) pNew->string = str;\r
- if (type == 2 || type == 4) pNew->mask = bmask;\r
- if (g_qeglobals.d_savedinfo.exclude & exclude)\r
- pNew->active = true;\r
- else\r
- pNew->active = false;\r
- return pNew;\r
-}\r
-\r
- // removes the filter list at *pFilter, returns NULL pointer\r
-bfilter_t *FilterListDelete(bfilter_t *pFilter)\r
-{\r
- if (pFilter != NULL)\r
- {\r
- FilterListDelete(pFilter->next);\r
- delete pFilter;\r
- }\r
- return NULL;\r
-}\r
-\r
-\r
- //spog - FilterUpdate is called each time the filters are changed by menu or shortcuts\r
-bfilter_t *FilterUpdate(bfilter_t *pFilter)\r
-{\r
- pFilter = FilterAdd(pFilter,1,0,"clip",EXCLUDE_CLIP);\r
- pFilter = FilterAdd(pFilter,1,0,"caulk",EXCLUDE_CAULK);\r
- pFilter = FilterAdd(pFilter,1,0,"liquids",EXCLUDE_LIQUIDS);\r
- pFilter = FilterAdd(pFilter,1,0,"hint",EXCLUDE_HINTSSKIPS);\r
- pFilter = FilterAdd(pFilter,1,0,"clusterportal",EXCLUDE_CLUSTERPORTALS);\r
- pFilter = FilterAdd(pFilter,1,0,"areaportal",EXCLUDE_AREAPORTALS);\r
- pFilter = FilterAdd(pFilter,2,QER_TRANS,NULL,EXCLUDE_TRANSLUCENT);\r
- pFilter = FilterAdd(pFilter,3,0,"trigger",EXCLUDE_TRIGGERS);\r
- pFilter = FilterAdd(pFilter,3,0,"misc_model",EXCLUDE_MODELS);\r
- pFilter = FilterAdd(pFilter,3,0,"misc_gamemodel",EXCLUDE_MODELS);\r
- pFilter = FilterAdd(pFilter,4,ECLASS_LIGHT,NULL,EXCLUDE_LIGHTS);\r
- pFilter = FilterAdd(pFilter,4,ECLASS_PATH,NULL,EXCLUDE_PATHS);\r
- pFilter = FilterAdd(pFilter,1,0,"lightgrid",EXCLUDE_LIGHTGRID);\r
- pFilter = FilterAdd(pFilter,1,0,"botclip",EXCLUDE_BOTCLIP);\r
- pFilter = FilterAdd(pFilter,1,0,"clipmonster",EXCLUDE_BOTCLIP);\r
- return pFilter;\r
-}\r
-\r
-/*\r
-==================\r
-FilterBrush\r
-==================\r
-*/\r
-\r
-bool FilterBrush(brush_t *pb)\r
-{\r
- \r
- if (!pb->owner)\r
- return FALSE; // during construction\r
- \r
- if (pb->hiddenBrush)\r
- return TRUE;\r
- \r
- if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_WORLD)\r
- {\r
- if (strcmp(pb->owner->eclass->name, "worldspawn") == 0 || !strcmp(pb->owner->eclass->name,"func_group")) // hack, treating func_group as world\r
- {\r
- return TRUE;\r
- }\r
- }\r
- \r
- if (g_qeglobals.d_savedinfo.exclude & EXCLUDE_ENT)\r
- {\r
- if (strcmp(pb->owner->eclass->name, "worldspawn") != 0 && strcmp(pb->owner->eclass->name,"func_group")) // hack, treating func_group as world\r
- {\r
- return TRUE;\r
- }\r
- }\r
- \r
- if ( g_qeglobals.d_savedinfo.exclude & EXCLUDE_CURVES )\r
- {\r
- if (pb->patchBrush)\r
- {\r
- return TRUE;\r
- }\r
- }\r
- \r
- \r
- if ( g_qeglobals.d_savedinfo.exclude & EXCLUDE_DETAILS )\r
- {\r
- if (!pb->patchBrush && pb->brush_faces->texdef.contents & CONTENTS_DETAIL )\r
- {\r
- return TRUE;\r
- }\r
- }\r
- if ( g_qeglobals.d_savedinfo.exclude & EXCLUDE_STRUCTURAL )\r
- {\r
- if (!pb->patchBrush && !( pb->brush_faces->texdef.contents & CONTENTS_DETAIL ))\r
- {\r
- return TRUE;\r
- }\r
- }\r
- \r
- // if brush belongs to world entity or a brushmodel entity and is not a patch\r
- if ( ( strcmp(pb->owner->eclass->name, "worldspawn") == 0\r
- || !strncmp( pb->owner->eclass->name, "func", 4)\r
- || !strncmp( pb->owner->eclass->name, "trigger", 7) ) && !pb->patchBrush )\r
- {\r
- bool filterbrush;\r
- for (face_t *f=pb->brush_faces;f!=NULL;f = f->next)\r
- {\r
- filterbrush=false;\r
- for (bfilter_t *filters = g_qeglobals.d_savedinfo.filters;\r
- filters != NULL;\r
- filters = filters->next)\r
- {\r
- // exclude by attribute 1 brush->face->pShader->getName()\r
- if (filters->active && filters->attribute == 1)\r
- {\r
- if (strstr(f->pShader->getName(),filters->string))\r
- {\r
- filterbrush=true;\r
- break;\r
- }\r
- }\r
- // exclude by attribute 2 brush->face->pShader->getFlags()\r
- else if (filters->active\r
- && filters->attribute == 2)\r
- {\r
- if (f->pShader->getFlags() & filters->mask)\r
- {\r
- filterbrush=true;\r
- break;\r
- }\r
- }\r
- }\r
- if (!filterbrush)\r
- break;\r
- }\r
- if (filterbrush)// if no face is found that should not be excluded\r
- return true; // exclude this brush\r
- }\r
-\r
- // if brush is a patch\r
- if ( pb->patchBrush )\r
- {\r
- bool drawpatch=true;\r
- for (bfilter_t *filters = g_qeglobals.d_savedinfo.filters;\r
- filters != NULL;\r
- filters = filters->next)\r
- {\r
- // exclude by attribute 1 (for patch) brush->pPatch->pShader->getName()\r
- if (filters->active\r
- && filters->attribute == 1)\r
- {\r
- if (strstr(pb->pPatch->pShader->getName(),filters->string))\r
- {\r
- drawpatch=false;\r
- break;\r
- }\r
- }\r
- \r
- // exclude by attribute 2 (for patch) brush->pPatch->pShader->getFlags()\r
- if (filters->active\r
- && filters->attribute == 2)\r
- {\r
- if (pb->pPatch->pShader->getFlags() & filters->mask)\r
- {\r
- drawpatch=false;\r
- break;\r
- }\r
- }\r
- }\r
- if (!drawpatch) // if a shader is found that should be excluded\r
- return TRUE; // exclude this patch\r
- }\r
- \r
- if (strcmp(pb->owner->eclass->name, "worldspawn") != 0) // if brush does not belong to world entity\r
- {\r
- bool drawentity=true;\r
- for (bfilter_t *filters = g_qeglobals.d_savedinfo.filters;\r
- filters != NULL;\r
- filters = filters->next)\r
- {\r
- // exclude by attribute 3 brush->owner->eclass->name\r
- if (filters->active\r
- && filters->attribute == 3)\r
- {\r
- if (strstr(pb->owner->eclass->name,filters->string))\r
- {\r
- drawentity=false;\r
- break;\r
- }\r
- }\r
- \r
- // exclude by attribute 4 brush->owner->eclass->nShowFlags\r
- else if (filters->active\r
- && filters->attribute == 4)\r
- {\r
- if ( pb->owner->eclass->nShowFlags & filters->mask )\r
- {\r
- drawentity=false;\r
- break;\r
- }\r
- }\r
- }\r
- if (!drawentity) // if an eclass property is found that should be excluded\r
- return TRUE; // exclude this brush\r
- }\r
- return FALSE;\r
-}\r
+/*
+ Copyright (C) 2001-2006, William Joseph.
+ All Rights Reserved.
+
+ This file is part of GtkRadiant.
+
+ GtkRadiant is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ GtkRadiant is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with GtkRadiant; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "filters.h"
+
+#include "debugging/debugging.h"
+
+#include "ifilter.h"
+
+#include "scenelib.h"
+
+#include <list>
+#include <set>
+
+#include "gtkutil/widget.h"
+#include "gtkutil/menu.h"
+#include "gtkmisc.h"
+#include "mainframe.h"
+#include "commands.h"
+#include "preferences.h"
+
+struct filters_globals_t {
+ std::size_t exclude;
+
+ filters_globals_t() :
+ exclude(0)
+ {
+ }
+};
+
+filters_globals_t g_filters_globals;
+
+inline bool filter_active(int mask)
+{
+ return (g_filters_globals.exclude & mask) > 0;
+}
+
+class FilterWrapper {
+public:
+ FilterWrapper(Filter &filter, int mask) : m_filter(filter), m_mask(mask)
+ {
+ }
+
+ void update()
+ {
+ m_filter.setActive(filter_active(m_mask));
+ }
+
+private:
+ Filter &m_filter;
+ int m_mask;
+};
+
+typedef std::list<FilterWrapper> Filters;
+Filters g_filters;
+
+typedef std::set<Filterable *> Filterables;
+Filterables g_filterables;
+
+void UpdateFilters()
+{
+ {
+ for (Filters::iterator i = g_filters.begin(); i != g_filters.end(); ++i) {
+ (*i).update();
+ }
+ }
+
+ {
+ for (Filterables::iterator i = g_filterables.begin(); i != g_filterables.end(); ++i) {
+ (*i)->updateFiltered();
+ }
+ }
+}
+
+
+class BasicFilterSystem : public FilterSystem {
+public:
+ void addFilter(Filter &filter, int mask)
+ {
+ g_filters.push_back(FilterWrapper(filter, mask));
+ g_filters.back().update();
+ }
+
+ void registerFilterable(Filterable &filterable)
+ {
+ ASSERT_MESSAGE(g_filterables.find(&filterable) == g_filterables.end(), "filterable already registered");
+ filterable.updateFiltered();
+ g_filterables.insert(&filterable);
+ }
+
+ void unregisterFilterable(Filterable &filterable)
+ {
+ ASSERT_MESSAGE(g_filterables.find(&filterable) != g_filterables.end(), "filterable not registered");
+ g_filterables.erase(&filterable);
+ }
+};
+
+BasicFilterSystem g_FilterSystem;
+
+FilterSystem &GetFilterSystem()
+{
+ return g_FilterSystem;
+}
+
+void PerformFiltering()
+{
+ UpdateFilters();
+ SceneChangeNotify();
+}
+
+class ToggleFilterFlag {
+ const unsigned int m_mask;
+public:
+ ToggleItem m_item;
+
+ ToggleFilterFlag(unsigned int mask) : m_mask(mask), m_item(ActiveCaller(*this))
+ {
+ }
+
+ ToggleFilterFlag(const ToggleFilterFlag &other) : m_mask(other.m_mask), m_item(ActiveCaller(*this))
+ {
+ }
+
+ void active(const Callback<void(bool)> &importCallback)
+ {
+ importCallback((g_filters_globals.exclude & m_mask) != 0);
+ }
+
+ typedef MemberCaller<ToggleFilterFlag, void(const Callback<void(bool)> &), &ToggleFilterFlag::active> ActiveCaller;
+
+ void toggle()
+ {
+ g_filters_globals.exclude ^= m_mask;
+ m_item.update();
+ PerformFiltering();
+ }
+
+ void reset()
+ {
+ g_filters_globals.exclude = 0;
+ m_item.update();
+ PerformFiltering();
+ }
+
+ typedef MemberCaller<ToggleFilterFlag, void(), &ToggleFilterFlag::toggle> ToggleCaller;
+};
+
+
+typedef std::list<ToggleFilterFlag> ToggleFilterFlags;
+ToggleFilterFlags g_filter_items;
+
+void add_filter_command(unsigned int flag, const char *command, const Accelerator &accelerator)
+{
+ g_filter_items.push_back(ToggleFilterFlag(flag));
+ GlobalToggles_insert(command, ToggleFilterFlag::ToggleCaller(g_filter_items.back()),
+ ToggleItem::AddCallbackCaller(g_filter_items.back().m_item), accelerator);
+}
+
+void InvertFilters()
+{
+ std::list<ToggleFilterFlag>::iterator iter;
+
+ for (iter = g_filter_items.begin(); iter != g_filter_items.end(); ++iter) {
+ iter->toggle();
+ }
+}
+
+void ResetFilters()
+{
+ std::list<ToggleFilterFlag>::iterator iter;
+
+ for (iter = g_filter_items.begin(); iter != g_filter_items.end(); ++iter) {
+ iter->reset();
+ }
+}
+
+void Filters_constructMenu(ui::Menu menu_in_menu)
+{
+ create_check_menu_item_with_mnemonic(menu_in_menu, "World", "FilterWorldBrushes");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Entities", "FilterEntities");
+ if (g_pGameDescription->mGameType == "doom3") {
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Visportals", "FilterVisportals");
+ } else {
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Areaportals", "FilterAreaportals");
+ }
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Translucent", "FilterTranslucent");
+ if (g_pGameDescription->mGameType != "doom3") {
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Liquids", "FilterLiquids");
+ }
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Caulk", "FilterCaulk");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Clips", "FilterClips");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Paths", "FilterPaths");
+ if (g_pGameDescription->mGameType != "doom3") {
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Clusterportals", "FilterClusterportals");
+ }
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Lights", "FilterLights");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Structural", "FilterStructural");
+ if (g_pGameDescription->mGameType != "doom3") {
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Lightgrid", "FilterLightgrid");
+ }
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Patches", "FilterPatches");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Details", "FilterDetails");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Hints", "FilterHintsSkips");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Models", "FilterModels");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Triggers", "FilterTriggers");
+ if (g_pGameDescription->mGameType != "doom3") {
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Botclips", "FilterBotClips");
+ create_check_menu_item_with_mnemonic(menu_in_menu, "Decals", "FilterDecals");
+ }
+ // filter manipulation
+ menu_separator(menu_in_menu);
+ create_menu_item_with_mnemonic(menu_in_menu, "Invert filters", "InvertFilters");
+ create_menu_item_with_mnemonic(menu_in_menu, "Reset filters", "ResetFilters");
+}
+
+
+#include "preferencesystem.h"
+#include "stringio.h"
+
+void ConstructFilters()
+{
+ GlobalPreferenceSystem().registerPreference("SI_Exclude", make_property_string(g_filters_globals.exclude));
+
+ GlobalCommands_insert("InvertFilters", makeCallbackF(InvertFilters));
+ GlobalCommands_insert("ResetFilters", makeCallbackF(ResetFilters));
+
+ add_filter_command(EXCLUDE_WORLD, "FilterWorldBrushes", Accelerator('1', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_ENT, "FilterEntities", Accelerator('2', (GdkModifierType) GDK_MOD1_MASK));
+ if (g_pGameDescription->mGameType == "doom3") {
+ add_filter_command(EXCLUDE_VISPORTALS, "FilterVisportals", Accelerator('3', (GdkModifierType) GDK_MOD1_MASK));
+ } else {
+ add_filter_command(EXCLUDE_AREAPORTALS, "FilterAreaportals", Accelerator('3', (GdkModifierType) GDK_MOD1_MASK));
+ }
+ add_filter_command(EXCLUDE_TRANSLUCENT, "FilterTranslucent", Accelerator('4', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_LIQUIDS, "FilterLiquids", Accelerator('5', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_CAULK, "FilterCaulk", Accelerator('6', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_CLIP, "FilterClips", Accelerator('7', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_PATHS, "FilterPaths", Accelerator('8', (GdkModifierType) GDK_MOD1_MASK));
+ if (g_pGameDescription->mGameType != "doom3") {
+ add_filter_command(EXCLUDE_CLUSTERPORTALS, "FilterClusterportals",
+ Accelerator('9', (GdkModifierType) GDK_MOD1_MASK));
+ }
+ add_filter_command(EXCLUDE_LIGHTS, "FilterLights", Accelerator('0', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_STRUCTURAL, "FilterStructural",
+ Accelerator('D', (GdkModifierType) (GDK_SHIFT_MASK | GDK_CONTROL_MASK)));
+ if (g_pGameDescription->mGameType != "doom3") {
+ add_filter_command(EXCLUDE_LIGHTGRID, "FilterLightgrid", accelerator_null());
+ }
+ add_filter_command(EXCLUDE_CURVES, "FilterPatches", Accelerator('P', (GdkModifierType) GDK_CONTROL_MASK));
+ add_filter_command(EXCLUDE_DETAILS, "FilterDetails", Accelerator('D', (GdkModifierType) GDK_CONTROL_MASK));
+ add_filter_command(EXCLUDE_HINTSSKIPS, "FilterHintsSkips", Accelerator('H', (GdkModifierType) GDK_CONTROL_MASK));
+ add_filter_command(EXCLUDE_MODELS, "FilterModels", Accelerator('M', (GdkModifierType) GDK_SHIFT_MASK));
+ add_filter_command(EXCLUDE_TRIGGERS, "FilterTriggers",
+ Accelerator('T', (GdkModifierType) (GDK_SHIFT_MASK | GDK_CONTROL_MASK)));
+ if (g_pGameDescription->mGameType != "doom3") {
+ add_filter_command(EXCLUDE_BOTCLIP, "FilterBotClips", Accelerator('M', (GdkModifierType) GDK_MOD1_MASK));
+ add_filter_command(EXCLUDE_DECALS, "FilterDecals", Accelerator('D', (GdkModifierType) GDK_SHIFT_MASK));
+ }
+
+ PerformFiltering();
+}
+
+void DestroyFilters()
+{
+ g_filters.clear();
+}
+
+#include "modulesystem/singletonmodule.h"
+#include "modulesystem/moduleregistry.h"
+
+class FilterAPI {
+ FilterSystem *m_filter;
+public:
+ typedef FilterSystem Type;
+
+ STRING_CONSTANT(Name, "*");
+
+ FilterAPI()
+ {
+ ConstructFilters();
+
+ m_filter = &GetFilterSystem();
+ }
+
+ ~FilterAPI()
+ {
+ DestroyFilters();
+ }
+
+ FilterSystem *getTable()
+ {
+ return m_filter;
+ }
+};
+
+typedef SingletonModule<FilterAPI> FilterModule;
+typedef Static<FilterModule> StaticFilterModule;
+StaticRegisterModule staticRegisterFilter(StaticFilterModule::instance());
projects / xonotic / netradiant.git / blobdiff