//
//////////////////////////////////////////////////////////////////////
-#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-gtk.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;
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();
ClearEPairs();
}
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* 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)
{
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);
+ Scene_forEachSelectedBrush(DEntityLoadBrushCaller(*this));
+}
- if(brush->pPatch)
- continue;
+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);
+ }
+ }
+};
- DBrush* loadBrush = NewBrush(i);
- loadBrush->LoadFromBrush_t(brush, TRUE);
- }
+template<typename Functor>
+inline const Functor& Scene_forEachSelectedPatch(const Functor& functor)
+{
+ GlobalSelectionSystem().foreachSelected(PatchSelectedVisitor<Functor>(functor));
+ return functor;
+}
- g_FuncTable.m_pfnReleaseSelectedBrushHandles();
+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;
}
}
}
if(selectList == NULL)
return;
- g_FuncTable.m_pfnDeselectAllBrushes();
+ GlobalSelectionSystem().setSelectedAll(false);
- g_FuncTable.m_pfnAllocateActiveBrushHandles();
+ scene::Path path(NodeReference(GlobalSceneGraph().root()));
+ path.push(NodeReference(*QER_Entity));
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))
+ if(string_equal_nocase(brushEntityList[i], m_Classname))
{
- keep = TRUE;
+ keep = true;
break;
}
}
if(!keep)
- 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);
+ return false;
- 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)
+ {
+ }
+ 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(brush->pPatch)
- {
- if(bLoadPatches)
- {
- DPatch* loadPatch = NewPatch();
- loadPatch->LoadFromBrush_t(brush);
- }
- }
- else
- {
- DBrush* loadBrush = NewBrush(i);
- loadBrush->LoadFromBrush_t(brush, TRUE);
- }
- }
+ 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;
+ }
+ } 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)
+void DEntity::RemoveNonCheckBrushes(std::list<Str>* exclusionList, bool useDetail)
{
- list<DBrush *>::iterator chkBrush=brushList.begin();
+ 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)
+void DEntity::ResetChecks(std::list<Str>* exclusionList)
{
- 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++)
{
(*resetBrush)->ResetChecks(exclusionList);
}
}
-int DEntity::FixBrushes(bool rebuild)
+int DEntity::FixBrushes()
{
- g_FuncTable.m_pfnAllocateActiveBrushHandles();
-
- int cnt = 0;
+ int count = 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)
if(makeEntity)
{
- entity_t* pE = (entity_t*)g_FuncTable.m_pfnCreateEntityHandle();
-
- epair_t* pEpS = GetNextChainItem(NULL, "classname", m_Classname);
+ NodeSmartReference node(GlobalEntityCreator().createEntity(GlobalEntityClassManager().findOrInsert(m_Classname.GetBuffer(), !brushList.empty() || !patchList.empty())));
- epair_t* pEp = pEpS;
-
- 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);
-
- g_FuncTable.m_pfnCommitEntityHandleToMap(pE);
+ Node_getTraversable(GlobalSceneGraph().root())->insert(node);
- for(list<DBrush *>::const_iterator buildBrush=brushList.begin(); buildBrush!=brushList.end(); buildBrush++)
- (*buildBrush)->BuildInRadiant(allowDestruction, NULL, pE);
+ for(std::list<DBrush *>::const_iterator buildBrush=brushList.begin(); buildBrush!=brushList.end(); buildBrush++)
+ (*buildBrush)->BuildInRadiant(allowDestruction, NULL, node.get_pointer());
- for(list<DPatch *>::const_iterator buildPatch=patchList.begin(); buildPatch!=patchList.end(); buildPatch++)
- (*buildPatch)->BuildInRadiant(pE);
+ for(std::list<DPatch *>::const_iterator buildPatch=patchList.begin(); buildPatch!=patchList.end(); buildPatch++)
+ (*buildPatch)->BuildInRadiant(node.get_pointer());
- 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);
}
epairList.clear();
}
-void DEntity::AddEPair(char *key, char *value) {
+void DEntity::AddEPair(const char *key, const char *value) {
DEPair* newEPair;
newEPair = FindEPairByKey( key );
if(!newEPair) {
}
}
-void DEntity::LoadEPairList(epair_t *epl)
+void DEntity::LoadEPairList(Entity *epl)
{
- epair_t* ep = epl;
- while(ep)
- {
- if(!strcmp(ep->key, "classname"))
- SetClassname(ep->value);
- else
- AddEPair(ep->key, ep->value);
+ class load_epairs_t : public Entity::Visitor
+ {
+ 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
+ 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;
}
{
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