//
//////////////////////////////////////////////////////////////////////
-#include "StdAfx.h"
+#include "DEntity.h"
-#ifdef _WIN32
+#ifdef WIN32
#pragma warning(disable : 4786)
#endif
-#include "DEntity.h"
+#include <list>
+#include "str.h"
+
+#include "DPoint.h"
+#include "DPlane.h"
+#include "DBrush.h"
+#include "DEPair.h"
+#include "DPatch.h"
#include "dialogs/dialogs-gtk.h"
#include "misc.h"
#include "CPortals.h"
+#include "iundo.h"
+#include "ientity.h"
+#include "ieclass.h"
+
+#include "generic/referencecounted.h"
+
+#include <vector>
+#include <list>
+#include <map>
+#include <algorithm>
+
+#include "scenelib.h"
+
+
const char* brushEntityList[] = {
"worldspawn",
"trigger_always",
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
-DEntity::DEntity( char *classname, int ID ){
+DEntity::DEntity( const char *classname, int ID ){
SetClassname( classname );
m_nID = ID;
QER_Entity = NULL;
//////////////////////////////////////////////////////////////////////
void DEntity::ClearBrushes(){
- for ( list<DBrush *>::const_iterator deadBrush = brushList.begin(); deadBrush != brushList.end(); deadBrush++ )
+ for ( std::list<DBrush *>::const_iterator deadBrush = brushList.begin(); deadBrush != brushList.end(); deadBrush++ )
{
delete *deadBrush;
}
}
void DEntity::ClearPatches(){
- for ( list<DPatch *>::const_iterator deadPatch = patchList.begin(); deadPatch != patchList.end(); deadPatch++ )
+ for ( std::list<DPatch *>::const_iterator deadPatch = patchList.begin(); deadPatch != patchList.end(); deadPatch++ )
{
delete *deadPatch;
}
portals.Load();
if ( portals.node_count == 0 ) {
- return FALSE;
+ return false;
}
ClearBrushes();
}
if ( !build ) {
- brush->AddFace( portals.node[i].portal[j].point[2].p, portals.node[i].portal[j].point[1].p, portals.node[i].portal[j].point[0].p, "textures/common/caulk", FALSE );
+ brush->AddFace( portals.node[i].portal[j].point[2].p, portals.node[i].portal[j].point[1].p, portals.node[i].portal[j].point[0].p, "textures/common/caulk", false );
}
else{
- brush->AddFace( portals.node[i].portal[j].point[0].p, portals.node[i].portal[j].point[1].p, portals.node[i].portal[j].point[2].p, "textures/common/caulk", FALSE );
+ brush->AddFace( portals.node[i].portal[j].point[0].p, portals.node[i].portal[j].point[1].p, portals.node[i].portal[j].point[2].p, "textures/common/caulk", false );
}
}
if ( build ) {
- brush->BuildInRadiant( FALSE, NULL );
+ brush->BuildInRadiant( false, NULL );
}
}
- return TRUE;
+ return true;
}
DPlane* DEntity::AddFaceToBrush( vec3_t va, vec3_t vb, vec3_t vc, _QERFaceData* faceData, int ID ){
DBrush* DEntity::GetBrushForID( int ID ){
DBrush* buildBrush = NULL;
- for ( list<DBrush *>::const_iterator chkBrush = brushList.begin(); chkBrush != brushList.end(); chkBrush++ )
+ for ( std::list<DBrush *>::const_iterator chkBrush = brushList.begin(); chkBrush != brushList.end(); chkBrush++ )
{
if ( ( *chkBrush )->m_nBrushID == ID ) {
buildBrush = ( *chkBrush );
return buildBrush;
}
+template<typename Functor>
+class BrushSelectedVisitor : public SelectionSystem::Visitor
+{
+const Functor& m_functor;
+public:
+BrushSelectedVisitor( const Functor& functor ) : m_functor( functor ){
+}
+void visit( scene::Instance& instance ) const {
+ if ( Node_isBrush( instance.path().top() ) ) {
+ m_functor( instance );
+ }
+}
+};
+
+template<typename Functor>
+inline const Functor& Scene_forEachSelectedBrush( const Functor& functor ){
+ GlobalSelectionSystem().foreachSelected( BrushSelectedVisitor<Functor>( functor ) );
+ return functor;
+}
+
+void DEntity_loadBrush( DEntity& entity, scene::Instance& brush ){
+ DBrush* loadBrush = entity.NewBrush( static_cast<int>( entity.brushList.size() ) );
+ loadBrush->LoadFromBrush( brush, true );
+}
+typedef ReferenceCaller1<DEntity, scene::Instance&, DEntity_loadBrush> DEntityLoadBrushCaller;
+
void DEntity::LoadSelectedBrushes(){
ClearBrushes();
ClearEPairs();
- int count = g_FuncTable.m_pfnAllocateSelectedBrushHandles();
-
- for ( int i = 0; i < count; i++ ) {
- brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetSelectedBrushHandle( i );
-
- if ( brush->pPatch ) {
- continue;
- }
+ Scene_forEachSelectedBrush( DEntityLoadBrushCaller( *this ) );
+}
- DBrush* loadBrush = NewBrush( i );
- loadBrush->LoadFromBrush_t( brush, TRUE );
+template<typename Functor>
+class PatchSelectedVisitor : public SelectionSystem::Visitor
+{
+const Functor& m_functor;
+public:
+PatchSelectedVisitor( const Functor& functor ) : m_functor( functor ){
+}
+void visit( scene::Instance& instance ) const {
+ if ( Node_isPatch( instance.path().top() ) ) {
+ m_functor( instance );
}
+}
+};
- g_FuncTable.m_pfnReleaseSelectedBrushHandles();
+template<typename Functor>
+inline const Functor& Scene_forEachSelectedPatch( const Functor& functor ){
+ GlobalSelectionSystem().foreachSelected( PatchSelectedVisitor<Functor>( functor ) );
+ return functor;
}
+void DEntity_loadPatch( DEntity& entity, scene::Instance& patch ){
+ DPatch* loadPatch = entity.NewPatch();
+ loadPatch->LoadFromPatch( patch );
+}
+typedef ReferenceCaller1<DEntity, scene::Instance&, DEntity_loadPatch> DEntityLoadPatchCaller;
+
void DEntity::LoadSelectedPatches(){
ClearPatches();
ClearEPairs();
- int count = g_FuncTable.m_pfnAllocateSelectedPatchHandles();
-
- for ( int i = 0; i < count; i++ )
- {
- //$ FIXME: m_pfnGetPatchHandle
- patchMesh_t *pmesh = (patchMesh_t*)g_FuncTable.m_pfnGetPatchData( i );
-
- DPatch* loadPatch = NewPatch();
- loadPatch->LoadFromBrush_t( pmesh->pSymbiot );
- }
-
- g_FuncTable.m_pfnReleasePatchHandles();
+ Scene_forEachSelectedPatch( DEntityLoadPatchCaller( *this ) );
}
bool* DEntity::BuildIntersectList(){
bool* pbIntList = new bool[max];
memset( pbIntList, 0, sizeof( bool ) * ( max ) );
- for ( list<DBrush *>::const_iterator pB1 = brushList.begin(); pB1 != brushList.end(); pB1++ )
+ for ( std::list<DBrush *>::const_iterator pB1 = brushList.begin(); pB1 != brushList.end(); pB1++ )
{
- list<DBrush *>::const_iterator pB2 = pB1;
+ std::list<DBrush *>::const_iterator pB2 = pB1;
for ( pB2++; pB2 != brushList.end(); pB2++ )
{
if ( ( *pB1 )->IntersectsWith( ( *pB2 ) ) ) {
- pbIntList[( *pB1 )->m_nBrushID] = TRUE;
- pbIntList[( *pB2 )->m_nBrushID] = TRUE;
+ pbIntList[( *pB1 )->m_nBrushID] = true;
+ pbIntList[( *pB2 )->m_nBrushID] = true;
}
}
}
bool* pbDupList = new bool[max];
memset( pbDupList, 0, sizeof( bool ) * ( max ) );
- for ( list<DBrush *>::const_iterator pB1 = brushList.begin(); pB1 != brushList.end(); pB1++ )
+ for ( std::list<DBrush *>::const_iterator pB1 = brushList.begin(); pB1 != brushList.end(); pB1++ )
{
- list<DBrush *>::const_iterator pB2 = pB1;
+ std::list<DBrush *>::const_iterator pB2 = pB1;
for ( pB2++; pB2 != brushList.end(); pB2++ )
{
if ( **pB1 == *pB2 ) {
- pbDupList[( *pB1 )->m_nBrushID] = TRUE;
- pbDupList[( *pB2 )->m_nBrushID] = TRUE;
+ pbDupList[( *pB1 )->m_nBrushID] = true;
+ pbDupList[( *pB2 )->m_nBrushID] = true;
}
}
}
return;
}
- g_FuncTable.m_pfnDeselectAllBrushes();
+ GlobalSelectionSystem().setSelectedAll( false );
- g_FuncTable.m_pfnAllocateActiveBrushHandles();
+ scene::Path path( NodeReference( GlobalSceneGraph().root() ) );
+ path.push( NodeReference( *QER_Entity ) );
- for ( list<DBrush *>::const_iterator pBrush = brushList.begin(); pBrush != brushList.end(); pBrush++ )
+ for ( std::list<DBrush *>::const_iterator pBrush = brushList.begin(); pBrush != brushList.end(); pBrush++ )
{
if ( selectList[( *pBrush )->m_nBrushID] ) {
- g_FuncTable.m_pfnSelectBrush( ( *pBrush )->QER_brush );
+ path.push( NodeReference( *( *pBrush )->QER_brush ) );
+ Instance_getSelectable( *GlobalSceneGraph().find( path ) )->setSelected( true );
+ path.pop();
}
}
- g_FuncTable.m_pfnReleaseActiveBrushHandles();
}
-bool DEntity::LoadFromEntity( int id, bool bLoadPatches ) {
- return LoadFromEntity( (entity_t*)g_FuncTable.m_pfnGetEntityHandle( id ), bLoadPatches );
-}
-
-bool DEntity::LoadFromEntity( entity_t* ent, bool bLoadPatches ) {
+bool DEntity::LoadFromEntity( scene::Node& ent, bool bLoadPatches ) {
ClearPatches();
ClearBrushes();
ClearEPairs();
- QER_Entity = ent;
+ QER_Entity = &ent;
- epair_t* epl = *g_EntityTable.m_pfnGetEntityKeyValList( QER_Entity );
- LoadEPairList( epl );
+ LoadEPairList( Node_getEntity( ent ) );
- bool keep = FALSE;
+ bool keep = false;
int i;
for ( i = 0; brushEntityList[i]; i++ )
{
- if ( !stricmp( brushEntityList[i], m_Classname ) ) {
- keep = TRUE;
+ if ( string_equal_nocase( brushEntityList[i], m_Classname ) ) {
+ keep = true;
break;
}
}
if ( !keep ) {
- return FALSE;
+ return false;
}
- int count = g_FuncTable.m_pfnAllocateEntityBrushHandles( QER_Entity );
-
- for ( i = 0; i < count; i++ )
- {
-
- brush_t *brush = (brush_t*)g_FuncTable.m_pfnGetEntityBrushHandle( i );
-
- if ( brush == NULL ) {
- DoMessageBox( "GTKRadiant returned a NULL pointer, NOT a good sign", "WARNING!!!", MB_OK );
- continue;
+ if ( Node_getTraversable( ent ) ) {
+ class load_brushes_t : public scene::Traversable::Walker
+ {
+ DEntity* m_entity;
+ mutable int m_count;
+public:
+ load_brushes_t( DEntity* entity )
+ : m_entity( entity ), m_count( 0 ){
}
-
- if ( brush->pPatch ) {
- if ( bLoadPatches ) {
- DPatch* loadPatch = NewPatch();
- loadPatch->LoadFromBrush_t( brush );
+ bool pre( scene::Node& node ) const {
+ scene::Path path( NodeReference( GlobalSceneGraph().root() ) );
+ path.push( NodeReference( *m_entity->QER_Entity ) );
+ path.push( NodeReference( node ) );
+ scene::Instance* instance = GlobalSceneGraph().find( path );
+ ASSERT_MESSAGE( instance != 0, "" );
+
+ if ( Node_isPatch( node ) ) {
+ DPatch* loadPatch = m_entity->NewPatch();
+ loadPatch->LoadFromPatch( *instance );
}
+ else if ( Node_isBrush( node ) ) {
+ DBrush* loadBrush = m_entity->NewBrush( m_count++ );
+ loadBrush->LoadFromBrush( *instance, true );
+ }
+ return false;
}
- else
- {
- DBrush* loadBrush = NewBrush( i );
- loadBrush->LoadFromBrush_t( brush, TRUE );
- }
- }
+ } load_brushes( this );
- g_FuncTable.m_pfnReleaseEntityBrushHandles();
+ Node_getTraversable( ent )->traverse( load_brushes );
+ }
- return TRUE;
+ return true;
}
-void DEntity::RemoveNonCheckBrushes( list<Str>* exclusionList, bool useDetail ){
- list<DBrush *>::iterator chkBrush = brushList.begin();
+void DEntity::RemoveNonCheckBrushes( std::list<Str>* exclusionList, bool useDetail ){
+ std::list<DBrush *>::iterator chkBrush = brushList.begin();
while ( chkBrush != brushList.end() )
{
}
}
- list<Str>::iterator eTexture;
+ std::list<Str>::iterator eTexture;
for ( eTexture = exclusionList->begin(); eTexture != exclusionList->end(); eTexture++ )
{
}
}
-void DEntity::ResetChecks( list<Str>* exclusionList ){
- for ( list<DBrush *>::const_iterator resetBrush = brushList.begin(); resetBrush != brushList.end(); resetBrush++ )
+void DEntity::ResetChecks( std::list<Str>* exclusionList ){
+ for ( std::list<DBrush *>::const_iterator resetBrush = brushList.begin(); resetBrush != brushList.end(); resetBrush++ )
{
( *resetBrush )->ResetChecks( exclusionList );
}
}
-int DEntity::FixBrushes( bool rebuild ){
- g_FuncTable.m_pfnAllocateActiveBrushHandles();
+int DEntity::FixBrushes(){
+ int count = 0;
- int cnt = 0;
-
- for ( list<DBrush *>::const_iterator fixBrush = brushList.begin(); fixBrush != brushList.end(); fixBrush++ )
+ for ( std::list<DBrush *>::const_iterator fixBrush = brushList.begin(); fixBrush != brushList.end(); fixBrush++ )
{
- int count = ( *fixBrush )->RemoveRedundantPlanes();
- if ( count ) {
- cnt += count;
- if ( rebuild ) {
- g_FuncTable.m_pfnDeleteBrushHandle( ( *fixBrush )->QER_brush );
-
- ( *fixBrush )->BuildInRadiant( FALSE, NULL );
- }
- }
+ count += ( *fixBrush )->RemoveRedundantPlanes();
}
- g_FuncTable.m_pfnReleaseActiveBrushHandles();
-
- return cnt;
+ return count;
}
void DEntity::BuildInRadiant( bool allowDestruction ){
bool makeEntity = strcmp( m_Classname, "worldspawn" ) ? true : false;
if ( makeEntity ) {
- entity_t* pE = (entity_t*)g_FuncTable.m_pfnCreateEntityHandle();
-
- epair_t* pEpS = GetNextChainItem( NULL, "classname", m_Classname );
-
- epair_t* pEp = pEpS;
+ NodeSmartReference node( GlobalEntityCreator().createEntity( GlobalEntityClassManager().findOrInsert( m_Classname.GetBuffer(), !brushList.empty() || !patchList.empty() ) ) );
- for ( list<DEPair* >::const_iterator buildEPair = epairList.begin(); buildEPair != epairList.end(); buildEPair++ )
+ for ( std::list<DEPair* >::const_iterator buildEPair = epairList.begin(); buildEPair != epairList.end(); buildEPair++ )
{
- pEp = GetNextChainItem( pEp, ( *buildEPair )->key, ( *buildEPair )->value );
+ Node_getEntity( node )->setKeyValue( ( *buildEPair )->key, ( *buildEPair )->value );
}
- g_EntityTable.m_pfnSetEntityKeyValList( pE, pEpS );
+ Node_getTraversable( GlobalSceneGraph().root() )->insert( node );
- g_FuncTable.m_pfnCommitEntityHandleToMap( pE );
+ for ( std::list<DBrush *>::const_iterator buildBrush = brushList.begin(); buildBrush != brushList.end(); buildBrush++ )
+ ( *buildBrush )->BuildInRadiant( allowDestruction, NULL, node.get_pointer() );
- for ( list<DBrush *>::const_iterator buildBrush = brushList.begin(); buildBrush != brushList.end(); buildBrush++ )
- ( *buildBrush )->BuildInRadiant( allowDestruction, NULL, pE );
+ for ( std::list<DPatch *>::const_iterator buildPatch = patchList.begin(); buildPatch != patchList.end(); buildPatch++ )
+ ( *buildPatch )->BuildInRadiant( node.get_pointer() );
- for ( list<DPatch *>::const_iterator buildPatch = patchList.begin(); buildPatch != patchList.end(); buildPatch++ )
- ( *buildPatch )->BuildInRadiant( pE );
-
- QER_Entity = pE;
+ QER_Entity = node.get_pointer();
}
else
{
- for ( list<DBrush *>::const_iterator buildBrush = brushList.begin(); buildBrush != brushList.end(); buildBrush++ )
+ for ( std::list<DBrush *>::const_iterator buildBrush = brushList.begin(); buildBrush != brushList.end(); buildBrush++ )
( *buildBrush )->BuildInRadiant( allowDestruction, NULL );
- for ( list<DPatch *>::const_iterator buildPatch = patchList.begin(); buildPatch != patchList.end(); buildPatch++ )
+ for ( std::list<DPatch *>::const_iterator buildPatch = patchList.begin(); buildPatch != patchList.end(); buildPatch++ )
( *buildPatch )->BuildInRadiant();
}
}
int DEntity::GetIDMax( void ) {
int max = -1;
- for ( list<DBrush *>::const_iterator cntBrush = brushList.begin(); cntBrush != brushList.end(); cntBrush++ ) {
+ for ( std::list<DBrush *>::const_iterator cntBrush = brushList.begin(); cntBrush != brushList.end(); cntBrush++ ) {
if ( ( *cntBrush )->m_nBrushID > max ) {
max = ( *cntBrush )->m_nBrushID;
}
return max + 1;
}
-void DEntity::SetClassname( char *classname ) {
+void DEntity::SetClassname( const char *classname ) {
m_Classname = classname;
}
fprintf( pFile, "\"classname\" \"%s\"\n", (const char *)m_Classname );
- for ( list<DEPair *>::const_iterator ep = epairList.begin(); ep != epairList.end(); ep++ )
+ for ( std::list<DEPair *>::const_iterator ep = epairList.begin(); ep != epairList.end(); ep++ )
{
fprintf( pFile, "\"%s\" \"%s\"\n", (const char *)( *ep )->key, (const char *)( *ep )->value );
}
- for ( list<DBrush *>::const_iterator bp = brushList.begin(); bp != brushList.end(); bp++ )
+ for ( std::list<DBrush *>::const_iterator bp = brushList.begin(); bp != brushList.end(); bp++ )
{
( *bp )->SaveToFile( pFile );
}
}
void DEntity::ClearEPairs(){
- for ( list<DEPair *>::const_iterator deadEPair = epairList.begin(); deadEPair != epairList.end(); deadEPair++ )
+ for ( std::list<DEPair *>::const_iterator deadEPair = epairList.begin(); deadEPair != epairList.end(); deadEPair++ )
{
delete ( *deadEPair );
}
}
}
-void DEntity::LoadEPairList( epair_t *epl ){
- epair_t* ep = epl;
- while ( ep )
+void DEntity::LoadEPairList( Entity *epl ){
+ class load_epairs_t : public Entity::Visitor
{
- if ( !strcmp( ep->key, "classname" ) ) {
- SetClassname( ep->value );
+ DEntity* m_entity;
+public:
+ load_epairs_t( DEntity* entity )
+ : m_entity( entity ){
+ }
+ void visit( const char* key, const char* value ){
+ if ( strcmp( key, "classname" ) == 0 ) {
+ m_entity->SetClassname( value );
}
else{
- AddEPair( ep->key, ep->value );
+ m_entity->AddEPair( key, value );
}
-
- ep = ep->next;
}
+
+ } load_epairs( this );
+
+ epl->forEachKeyValue( load_epairs );
}
bool DEntity::ResetTextures( const char* textureName, float fScale[2], float fShift[2], int rotation, const char* newTextureName,
int bResetTextureName, int bResetScale[2], int bResetShift[2], int bResetRotation, bool rebuild ){
- g_FuncTable.m_pfnDeselectAllBrushes();
+ bool reset = false;
- g_FuncTable.m_pfnAllocateActiveBrushHandles();
-
- bool reset = FALSE;
-
- for ( list<DBrush *>::const_iterator resetBrush = brushList.begin(); resetBrush != brushList.end(); resetBrush++ )
+ for ( std::list<DBrush *>::const_iterator resetBrush = brushList.begin(); resetBrush != brushList.end(); resetBrush++ )
{
bool tmp = ( *resetBrush )->ResetTextures( textureName, fScale, fShift, rotation, newTextureName,
bResetTextureName, bResetScale, bResetShift, bResetRotation );
if ( tmp ) {
- reset = TRUE;
-
+ reset = true;
if ( rebuild ) {
- entity_t *pE = ( *resetBrush )->QER_brush->owner;
- g_FuncTable.m_pfnDeleteBrushHandle( ( *resetBrush )->QER_brush );
- ( *resetBrush )->BuildInRadiant( FALSE, NULL, pE->entityId == 0 ? NULL : pE );
-
- if ( pE->entityId == 0 ? NULL : pE ) {
- }
+ Node_getTraversable( *( *resetBrush )->QER_entity )->erase( *( *resetBrush )->QER_brush );
+ ( *resetBrush )->BuildInRadiant( false, NULL, ( *resetBrush )->QER_entity );
}
}
}
if ( bResetTextureName ) {
- for ( list<DPatch *>::const_iterator resetPatch = patchList.begin(); resetPatch != patchList.end(); resetPatch++ )
+ for ( std::list<DPatch *>::const_iterator resetPatch = patchList.begin(); resetPatch != patchList.end(); resetPatch++ )
{
bool tmp = ( *resetPatch )->ResetTextures( textureName, newTextureName );
if ( tmp ) {
- reset = TRUE;
-
+ reset = true;
if ( rebuild ) {
- entity_t *pE = ( *resetPatch )->QER_brush->owner;
- g_FuncTable.m_pfnDeleteBrushHandle( ( *resetPatch )->QER_brush );
- ( *resetPatch )->BuildInRadiant( pE->entityId == 0 ? NULL : pE );
+ Node_getTraversable( *( *resetPatch )->QER_entity )->erase( *( *resetPatch )->QER_brush );
+ ( *resetPatch )->BuildInRadiant( ( *resetPatch )->QER_entity );
}
}
}
}
- g_FuncTable.m_pfnReleaseActiveBrushHandles();
-
return reset;
}
DEPair* DEntity::FindEPairByKey( const char* keyname ){
- for ( list<DEPair *>::const_iterator ep = epairList.begin(); ep != epairList.end(); ep++ )
+ for ( std::list<DEPair *>::const_iterator ep = epairList.begin(); ep != epairList.end(); ep++ )
{
char* c = ( *ep )->key;
if ( !strcmp( c, keyname ) ) {
}
void DEntity::RemoveFromRadiant(){
- g_EntityTable.m_pfnEntity_Free( (entity_t*)QER_Entity );
+ Node_getTraversable( GlobalSceneGraph().root() )->erase( *QER_Entity );
QER_Entity = NULL;
}
void DEntity::SpawnFloat( const char* key, const char* defaultstring, float* out ){
DEPair* pEP = FindEPairByKey( key );
if ( pEP ) {
- *out = static_cast< float >( atof( pEP->value ) );
+ *out = static_cast<float>( atof( pEP->value ) );
}
else {
- *out = static_cast< float >( atof( defaultstring ) );
+ *out = static_cast<float>( atof( defaultstring ) );
}
}
}
int DEntity::GetBrushCount( void ) {
- return brushList.size();
+ return static_cast<int>( brushList.size() );
}
-DBrush* DEntity::FindBrushByPointer( brush_t* brush ) {
- for ( list<DBrush *>::const_iterator listBrush = brushList.begin(); listBrush != brushList.end(); listBrush++ ) {
+DBrush* DEntity::FindBrushByPointer( scene::Node& brush ) {
+ for ( std::list<DBrush *>::const_iterator listBrush = brushList.begin(); listBrush != brushList.end(); listBrush++ ) {
DBrush* pBrush = ( *listBrush );
- if ( pBrush->QER_brush == brush ) {
+ if ( pBrush->QER_brush == &brush ) {
return pBrush;
}
}
projects / xonotic / netradiant.git / blobdiff