Code/Sandbox/EditorQt/Objects/AreaBox.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "AreaBox.h"
   5 #include "Viewport.h"
   6 #include <Preferences/ViewportPreferences.h>
   7 #include "Controls/PropertiesPanel.h"
   8 #include "Objects/ObjectLoader.h"
   9 #include "Objects/InspectorWidgetCreator.h"
  10 #include <CryEntitySystem/IEntity.h>
  11
  12 #include <Serialization/Decorators/EntityLink.h>
  13 #include <Serialization/Decorators/EditorActionButton.h>
  14 #include <Serialization/Decorators/EditToolButton.h>
  15
  16 #include "PickObjectTool.h"
  17
  18 REGISTER_CLASS_DESC(CAreaBoxClassDesc);
  19
  20 class AreaTargetTool : public CPickObjectTool
  21 {
  22         DECLARE_DYNCREATE(AreaTargetTool)
  23
  24         struct SAreaTargetPicker : IPickObjectCallback
  25         {
  26                 SAreaTargetPicker()
  27                 {
  28                 }
  29
  30                 void OnPick(CBaseObject* pObj) override
  31                 {
  32                         if (m_owner)
  33                         {
  34                                 CUndo undo("Add target link");
  35                                 m_owner->AddEntity(pObj);
  36                         }
  37                 }
  38
  39                 void OnCancelPick() override
  40                 {
  41                 }
  42
  43                 CAreaObjectBase* m_owner;
  44         };
  45
  46 public:
  47         AreaTargetTool()
  48                 : CPickObjectTool(&m_picker)
  49         {
  50         }
  51
  52         virtual void SetUserData(const char* key, void* userData) override
  53         {
  54                 m_picker.m_owner = static_cast<CAreaObjectBase*>(userData);
  55         }
  56
  57 private:
  58         SAreaTargetPicker m_picker;
  59 };
  60
  61 IMPLEMENT_DYNCREATE(AreaTargetTool, CPickObjectTool)
  62
  63 //////////////////////////////////////////////////////////////////////////
  64 CAreaObjectBase::CAreaObjectBase()
  65 {
  66         m_entities.RegisterEventCallback(functor(*this, &CAreaObjectBase::OnObjectEvent));
  67 }
  68
  69 //////////////////////////////////////////////////////////////////////////
  70 CAreaObjectBase::~CAreaObjectBase()
  71 {
  72         m_entities.UnregisterEventCallback(functor(*this, &CAreaObjectBase::OnObjectEvent));
  73 }
  74
  75 //////////////////////////////////////////////////////////////////////////
  76 void CAreaObjectBase::SerializeEntityTargets(Serialization::IArchive& ar, bool bMultiEdit)
  77 {
  78         std::vector<Serialization::EntityTarget> links;
  79         for (size_t i = 0; i < m_entities.GetCount(); i++)
  80         {
  81                 links.emplace_back(m_entities.Get(i)->GetId(), (LPCTSTR)m_entities.Get(i)->GetName());
  82         }
  83
  84         ar(links, "attached_entities", "!Attached Entities");
  85         if (ar.isInput())
  86         {
  87                 size_t linkCount = links.size();
  88                 bool linksChanged = m_entities.GetCount() != linkCount;
  89
  90                 if (!linksChanged)
  91                 {
  92                         for (size_t i = 0; i < m_entities.GetCount(); i++)
  93                         {
  94                                 if (m_entities.Get(i)->GetId() != links[i].guid)
  95                                 {
  96                                         linksChanged = true;
  97                                 }
  98                         }
  99                 }
 100
 101                 if (linksChanged)
 102                 {
 103                         while (!m_entities.IsEmpty())
 104                         {
 105                                 RemoveEntity(0);
 106                         }
 107
 108                         for (size_t i = 0; i < links.size(); i++)
 109                         {
 110                                 CBaseObject* obj = GetIEditorImpl()->GetObjectManager()->FindObject(links[i].guid);
 111                                 if (obj)
 112                                 {
 113                                         AddEntity(obj);
 114                                 }
 115                         }
 116                 }
 117         }
 118
 119         if (ar.isEdit())
 120         {
 121                 if (ar.openBlock("linktools", "Target Tools"))
 122                 {
 123                         Serialization::SEditToolButton pickToolButton("");
 124                         pickToolButton.SetToolClass(RUNTIME_CLASS(AreaTargetTool), nullptr, this);
 125
 126                         ar(pickToolButton, "picker", "^Pick");
 127                         ar(Serialization::ActionButton([ = ] {
 128                                 CUndo undo("Clear entity links");
 129                                 while (!m_entities.IsEmpty())
 130                                 {
 131                                   RemoveEntity(0);
 132                                 }
 133                         }), "picker", "^Clear");
 134
 135                         ar.closeBlock();
 136                 }
 137         }
 138 }
 139
 140 void CAreaObjectBase::CreateInspectorWidgets(CInspectorWidgetCreator& creator)
 141 {
 142         CEntityObject::CreateInspectorWidgets(creator);
 143
 144         creator.AddPropertyTree<CAreaObjectBase>("Area", &CAreaObjectBase::SerializeEntityTargets);
 145 }
 146
 147 //////////////////////////////////////////////////////////////////////////
 148 void CAreaObjectBase::PostClone(CBaseObject* pFromObject, CObjectCloneContext& ctx)
 149 {
 150         __super::PostClone(pFromObject, ctx);
 151
 152         CAreaObjectBase const* const pFrom = static_cast<CAreaObjectBase*>(pFromObject);
 153         // Clone event targets.
 154         if (!pFrom->m_entities.IsEmpty())
 155         {
 156                 size_t const numEntities = pFrom->m_entities.GetCount();
 157
 158                 for (size_t i = 0; i < numEntities; i++)
 159                 {
 160                         CBaseObject* const __restrict pBaseObject = pFrom->m_entities.Get(i);
 161                         CBaseObject* const __restrict pClonedBaseObject = ctx.FindClone(pBaseObject);
 162
 163                         if (pClonedBaseObject != nullptr)
 164                         {
 165                                 m_entities.Add(pClonedBaseObject);
 166                         }
 167                         else
 168                         {
 169                                 m_entities.Add(pBaseObject);
 170                         }
 171                 }
 172         }
 173 }
 174
 175 //////////////////////////////////////////////////////////////////////////
 176 void CAreaObjectBase::OnObjectEvent(CBaseObject* const pBaseObject, int const event)
 177 {
 178         if (event == OBJECT_ON_PREDELETE)
 179         {
 180                 if (pBaseObject->IsKindOf(RUNTIME_CLASS(CEntityObject)))
 181                 {
 182                         CEntityObject const* const pEntityObject = static_cast<CEntityObject*>(pBaseObject);
 183
 184                         if (pEntityObject != nullptr && pEntityObject->GetIEntity() != nullptr)
 185                         {
 186                                 OnEntityRemoved(pEntityObject->GetIEntity());
 187                         }
 188                 }
 189         }
 190 }
 191
 192 //////////////////////////////////////////////////////////////////////////
 193 void CAreaObjectBase::AddEntity(CBaseObject* const pBaseObject)
 194 {
 195         CRY_ASSERT(pBaseObject != nullptr);
 196         StoreUndo("Add Entity");
 197         m_entities.Add(pBaseObject);
 198
 199         if (pBaseObject->IsKindOf(RUNTIME_CLASS(CEntityObject)))
 200         {
 201                 OnEntityAdded(static_cast<CEntityObject*>(pBaseObject)->GetIEntity());
 202         }
 203
 204         UpdateUIVars();
 205 }
 206
 207 //////////////////////////////////////////////////////////////////////////
 208 void CAreaObjectBase::RemoveEntity(size_t const index)
 209 {
 210         CRY_ASSERT(index >= 0 && index < m_entities.GetCount());
 211
 212         if (index < m_entities.GetCount())
 213         {
 214                 StoreUndo("Remove Entity");
 215                 CBaseObject* const pBaseObject = m_entities.Get(index);
 216                 CEntityObject const* const pEntity = GetEntity(index);
 217
 218                 if (pEntity != nullptr)
 219                 {
 220                         OnEntityRemoved(pEntity->GetIEntity());
 221                 }
 222
 223                 m_entities.Remove(pBaseObject);
 224
 225                 UpdateUIVars();
 226         }
 227 }
 228
 229 //////////////////////////////////////////////////////////////////////////
 230 CEntityObject* CAreaObjectBase::GetEntity(size_t const index)
 231 {
 232         CRY_ASSERT(index >= 0 && index < m_entities.GetCount());
 233         CBaseObject* const pBaseObject = m_entities.Get(index);
 234
 235         if (pBaseObject != nullptr && pBaseObject->IsKindOf(RUNTIME_CLASS(CEntityObject)))
 236         {
 237                 return static_cast<CEntityObject*>(pBaseObject);
 238         }
 239
 240         return nullptr;
 241 }
 242
 243 //////////////////////////////////////////////////////////////////////////
 244 void CAreaObjectBase::Serialize(CObjectArchive& ar)
 245 {
 246         __super::Serialize(ar);
 247
 248         XmlNodeRef xmlNode = ar.node;
 249         if (ar.bLoading)
 250         {
 251                 m_entities.Clear();
 252                 XmlNodeRef const entities = xmlNode->findChild("Entities");
 253
 254                 if (entities)
 255                 {
 256                         int const numChildren = entities->getChildCount();
 257
 258                         for (int i = 0; i < numChildren; ++i)
 259                         {
 260                                 XmlNodeRef const ent = entities->getChild(i);
 261                                 CryGUID entityId;
 262
 263                                 if (ent->getAttr("Id", entityId))
 264                                 {
 265                                         ar.SetResolveCallback(this, entityId, functor(m_entities, &CSafeObjectsArray::Add));
 266                                 }
 267                         }
 268                 }
 269         }
 270         else
 271         {
 272                 if (!m_entities.IsEmpty())
 273                 {
 274                         XmlNodeRef const nodes = xmlNode->newChild("Entities");
 275                         size_t const numEntities = m_entities.GetCount();
 276
 277                         for (size_t i = 0; i < numEntities; i++)
 278                         {
 279                                 XmlNodeRef entNode = nodes->newChild("Entity");
 280
 281                                 if (m_entities.Get(i) != nullptr)
 282                                 {
 283                                         entNode->setAttr("Id", m_entities.Get(i)->GetId());
 284                                 }
 285                         }
 286                 }
 287         }
 288 }
 289
 290 //////////////////////////////////////////////////////////////////////////
 291 void CAreaObjectBase::DrawEntityLinks(DisplayContext& dc)
 292 {
 293         if (!m_entities.IsEmpty())
 294         {
 295                 Vec3 const vcol = Vec3(1.0f, 1.0f, 1.0f);
 296                 size_t const numEntities = m_entities.GetCount();
 297
 298                 for (size_t i = 0; i < numEntities; ++i)
 299                 {
 300                         CBaseObject const* const pBaseObject = GetEntity(i);
 301
 302                         if (pBaseObject != nullptr)
 303                         {
 304                                 dc.DrawLine(GetWorldPos(), pBaseObject->GetWorldPos(), ColorF(vcol.x, vcol.y, vcol.z, 0.7f), ColorF(1, 1, 1, 0.7f));
 305                         }
 306                 }
 307         }
 308 }
 309
 310 //////////////////////////////////////////////////////////////////////////
 311 // CBase implementation.
 312 //////////////////////////////////////////////////////////////////////////
 313 IMPLEMENT_DYNCREATE(CAreaBox, CEntityObject)
 314
 315 //////////////////////////////////////////////////////////////////////////
 316 CAreaBox::CAreaBox()
 317         : m_innerFadeDistance(0.0f)
 318 {
 319         m_areaId = -1;
 320         m_edgeWidth = 0;
 321         mv_width = 4;
 322         mv_length = 4;
 323         mv_height = 1;
 324         mv_groupId = 0;
 325         mv_priority = 0;
 326         mv_filled = false;
 327         mv_displaySoundInfo = false;
 328         m_entityClass = "AreaBox";
 329
 330         // Resize for 6 sides
 331         m_abObstructSound.resize(6);
 332
 333         m_box.min = Vec3(-mv_width / 2, -mv_length / 2, 0);
 334         m_box.max = Vec3(mv_width / 2, mv_length / 2, mv_height);
 335
 336         m_bIgnoreGameUpdate = 1;
 337
 338         m_pOwnSoundVarBlock = new CVarBlock;
 339 }
 340
 341 //////////////////////////////////////////////////////////////////////////
 342 void CAreaBox::InitVariables()
 343 {
 344         if (m_pVarObject == nullptr)
 345         {
 346                 m_pVarObject = stl::make_unique<CVarObject>();
 347         }
 348
 349         m_pVarObject->AddVariable(m_innerFadeDistance, "InnerFadeDistance", functor(*this, &CAreaBox::OnAreaChange));
 350         m_pVarObject->AddVariable(m_areaId, "AreaId", functor(*this, &CAreaBox::OnAreaChange));
 351         m_pVarObject->AddVariable(m_edgeWidth, "FadeInZone", functor(*this, &CAreaBox::OnSizeChange));
 352         m_pVarObject->AddVariable(mv_width, "Width", functor(*this, &CAreaBox::OnSizeChange));
 353         m_pVarObject->AddVariable(mv_length, "Length", functor(*this, &CAreaBox::OnSizeChange));
 354         m_pVarObject->AddVariable(mv_height, "Height", functor(*this, &CAreaBox::OnSizeChange));
 355         m_pVarObject->AddVariable(mv_groupId, "GroupId", functor(*this, &CAreaBox::OnAreaChange));
 356         m_pVarObject->AddVariable(mv_priority, "Priority", functor(*this, &CAreaBox::OnAreaChange));
 357         m_pVarObject->AddVariable(mv_filled, "DisplayFilled");
 358         m_pVarObject->AddVariable(mv_displaySoundInfo, "DisplaySoundInfo", functor(*this, &CAreaBox::OnSoundParamsChange));
 359 }
 360
 361 //////////////////////////////////////////////////////////////////////////
 362 void CAreaBox::Done()
 363 {
 364         m_pOwnSoundVarBlock->DeleteAllVariables();
 365
 366         CEntityObject::Done();
 367 }
 368
 369 //////////////////////////////////////////////////////////////////////////
 370 bool CAreaBox::Init(CBaseObject* prev, const string& file)
 371 {
 372         m_bIgnoreGameUpdate = 1;
 373
 374         SetColor(RGB(0, 0, 255));
 375         bool res = CEntityObject::Init(prev, file);
 376
 377         if (m_pEntity != nullptr)
 378         {
 379                 m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 380         }
 381
 382         if (prev)
 383         {
 384                 m_abObstructSound = ((CAreaBox*)prev)->m_abObstructSound;
 385                 CRY_ASSERT(m_abObstructSound.size() == 6);
 386         }
 387
 388         m_bIgnoreGameUpdate = 0;
 389
 390         return res;
 391 }
 392
 393 //////////////////////////////////////////////////////////////////////////
 394 void CAreaBox::GetLocalBounds(AABB& box)
 395 {
 396         box = m_box;
 397 }
 398
 399 //////////////////////////////////////////////////////////////////////////
 400 bool CAreaBox::HitTest(HitContext& hc)
 401 {
 402         Vec3 p;
 403         /*BBox box;
 404            box = m_box;
 405            box.Transform( GetWorldTM() );
 406            float tr = hc.distanceTollerance/2;
 407            box.min -= Vec3(tr,tr,tr);
 408            box.max += Vec3(tr,tr,tr);
 409            if (box.IsIntersectRay(hc.raySrc,hc.rayDir,p ))
 410            {
 411            hc.dist = Vec3(hc.raySrc - p).Length();
 412            return true;
 413            }*/
 414         Matrix34 invertWTM = GetWorldTM();
 415         Vec3 worldPos = invertWTM.GetTranslation();
 416         invertWTM.Invert();
 417
 418         Vec3 xformedRaySrc = invertWTM.TransformPoint(hc.raySrc);
 419         Vec3 xformedRayDir = invertWTM.TransformVector(hc.rayDir).GetNormalized();
 420
 421         float epsilonDist = max(.1f, hc.view->GetScreenScaleFactor(worldPos) * 0.01f);
 422         epsilonDist *= max(0.0001f, min(invertWTM.GetColumn0().GetLength(), min(invertWTM.GetColumn1().GetLength(), invertWTM.GetColumn2().GetLength())));
 423         float hitDist;
 424
 425         float tr = hc.distanceTolerance / 2 + 1;
 426         AABB box;
 427         box.min = m_box.min - Vec3(tr + epsilonDist, tr + epsilonDist, tr + epsilonDist);
 428         box.max = m_box.max + Vec3(tr + epsilonDist, tr + epsilonDist, tr + epsilonDist);
 429
 430         if (Intersect::Ray_AABB(xformedRaySrc, xformedRayDir, box, p))
 431         {
 432                 if (Intersect::Ray_AABBEdge(xformedRaySrc, xformedRayDir, m_box, epsilonDist, hitDist, p))
 433                 {
 434                         hc.dist = xformedRaySrc.GetDistance(p);
 435                         return true;
 436                 }
 437         }
 438         return false;
 439 }
 440
 441 //////////////////////////////////////////////////////////////////////////
 442 void CAreaBox::CreateInspectorWidgets(CInspectorWidgetCreator& creator)
 443 {
 444         CAreaObjectBase::CreateInspectorWidgets(creator);
 445
 446         creator.AddPropertyTree<CAreaBox>("Area Box", &CAreaBox::SerializeProperties);
 447 }
 448
 449 void CAreaBox::SerializeProperties(Serialization::IArchive& ar, bool bMultiEdit)
 450 {
 451         m_pVarObject->SerializeVariable(&m_innerFadeDistance, ar);
 452         m_pVarObject->SerializeVariable(&m_areaId, ar);
 453         m_pVarObject->SerializeVariable(&m_edgeWidth, ar);
 454         m_pVarObject->SerializeVariable(&mv_width, ar);
 455         m_pVarObject->SerializeVariable(&mv_length, ar);
 456         m_pVarObject->SerializeVariable(&mv_height, ar);
 457         m_pVarObject->SerializeVariable(&mv_groupId, ar);
 458         m_pVarObject->SerializeVariable(&mv_priority, ar);
 459         m_pVarObject->SerializeVariable(&mv_filled, ar);
 460         m_pVarObject->SerializeVariable(&mv_displaySoundInfo, ar);
 461
 462         if (!m_abObstructSound.empty() && !m_bIgnoreGameUpdate && mv_displaySoundInfo && !bMultiEdit)
 463         {
 464                 if (!ar.isInput() || m_pOwnSoundVarBlock->IsEmpty())
 465                 {
 466                         if (!m_pOwnSoundVarBlock->IsEmpty())
 467                                 m_pOwnSoundVarBlock->DeleteAllVariables();
 468                         // If the shape hasn't got a height subtract 2 for roof and floor
 469                         CRY_ASSERT(m_abObstructSound.size() == 6);
 470                         size_t const nVarCount = m_abObstructSound.size() - ((mv_height > 0.0f) ? 0 : 2);
 471                         for (size_t i = 0; i < nVarCount; ++i)
 472                         {
 473                                 CVariable<bool>* const pvTemp = new CVariable<bool>;
 474                                 pvTemp->Set(m_abObstructSound[i]);
 475                                 pvTemp->AddOnSetCallback(functor(*this, &CAreaBox::OnPointChange));
 476
 477                                 string cTemp;
 478                                 cTemp.Format("Side:%d", i + 1);
 479
 480                                 pvTemp->SetName(cTemp);
 481                                 m_pOwnSoundVarBlock->AddVariable(pvTemp);
 482                         }
 483                 }
 484
 485                 ar(*m_pOwnSoundVarBlock, "SoundObstruction", "|Sound Obstruction");
 486         }
 487 }
 488
 489 //////////////////////////////////////////////////////////////////////////
 490 void CAreaBox::Reload(bool bReloadScript /* = false */)
 491 {
 492         __super::Reload(bReloadScript);
 493
 494         // During reloading the entity+proxies get completely removed.
 495         // Hence we need to completely recreate the proxy and update all data to it.
 496         UpdateGameArea();
 497 }
 498
 499 //////////////////////////////////////////////////////////////////////////
 500 void CAreaBox::OnAreaChange(IVariable* pVariable)
 501 {
 502         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 503         {
 504                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 505
 506                 if (pArea)
 507                 {
 508                         pArea->SetID(m_areaId);
 509                         pArea->SetGroup(mv_groupId);
 510                         pArea->SetPriority(mv_priority);
 511                         pArea->SetInnerFadeDistance(m_innerFadeDistance);
 512                 }
 513         }
 514 }
 515
 516 //////////////////////////////////////////////////////////////////////////
 517 void CAreaBox::OnSizeChange(IVariable* pVariable)
 518 {
 519         Vec3 size(0, 0, 0);
 520         size.x = mv_width;
 521         size.y = mv_length;
 522         size.z = mv_height;
 523
 524         m_box.min = -size / 2;
 525         m_box.max = size / 2;
 526         // Make volume position bottom of bounding box.
 527         m_box.min.z = 0;
 528         m_box.max.z = size.z;
 529
 530         InvalidateWorldBox();
 531
 532         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 533         {
 534                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 535
 536                 if (pArea)
 537                 {
 538                         pArea->SetBox(m_box.min, m_box.max, nullptr, 0);
 539                         pArea->SetProximity(m_edgeWidth);
 540                 }
 541         }
 542 }
 543
 544 //////////////////////////////////////////////////////////////////////////
 545 void CAreaBox::Display(DisplayContext& dc)
 546 {
 547         if (!gViewportDebugPreferences.showAreaObjectHelper)
 548                 return;
 549
 550         if (!mv_displaySoundInfo)
 551         {
 552                 COLORREF wireColor, solidColor;
 553                 float wireOffset = 0;
 554                 float alpha = 0.3f;
 555                 if (IsSelected())
 556                 {
 557                         wireColor = dc.GetSelectedColor();
 558                         solidColor = GetColor();
 559                         wireOffset = -0.1f;
 560                 }
 561                 else
 562                 {
 563                         wireColor = GetColor();
 564                         solidColor = GetColor();
 565                 }
 566
 567                 //dc.renderer->SetCullMode( R_CULL_DISABLE );
 568
 569                 dc.PushMatrix(GetWorldTM());
 570                 AABB box = m_box;
 571
 572                 bool bFrozen = IsFrozen();
 573
 574                 if (bFrozen)
 575                         dc.SetFreezeColor();
 576                 //////////////////////////////////////////////////////////////////////////
 577                 if (!bFrozen)
 578                         dc.SetColor(solidColor, alpha);
 579
 580                 if (IsSelected())
 581                 {
 582                         dc.DepthWriteOff();
 583                         dc.DrawSolidBox(box.min, box.max);
 584                         dc.DepthWriteOn();
 585                 }
 586
 587                 if (!bFrozen)
 588                         dc.SetColor(wireColor, 1);
 589
 590                 if (IsSelected())
 591                 {
 592                         dc.SetLineWidth(3.0f);
 593                         dc.DrawWireBox(box.min, box.max);
 594                         dc.SetLineWidth(0);
 595                 }
 596                 else
 597                         dc.DrawWireBox(box.min, box.max);
 598                 if (m_edgeWidth)
 599                 {
 600                         float fFadeScale = m_edgeWidth / 200.0f;
 601                         AABB InnerBox = box;
 602                         Vec3 EdgeDist = InnerBox.max - InnerBox.min;
 603                         InnerBox.min.x += EdgeDist.x * fFadeScale;
 604                         InnerBox.max.x -= EdgeDist.x * fFadeScale;
 605                         InnerBox.min.y += EdgeDist.y * fFadeScale;
 606                         InnerBox.max.y -= EdgeDist.y * fFadeScale;
 607                         InnerBox.min.z += EdgeDist.z * fFadeScale;
 608                         InnerBox.max.z -= EdgeDist.z * fFadeScale;
 609                         dc.DrawWireBox(InnerBox.min, InnerBox.max);
 610                 }
 611                 if (mv_filled)
 612                 {
 613                         dc.SetAlpha(0.2f);
 614                         dc.DrawSolidBox(box.min, box.max);
 615                 }
 616                 //////////////////////////////////////////////////////////////////////////
 617
 618                 dc.PopMatrix();
 619
 620                 DrawEntityLinks(dc);
 621                 DrawDefault(dc);
 622         }
 623         else
 624         {
 625                 ColorB const oObstructionFilled(255, 0, 0, 120);
 626                 ColorB const oObstructionFilledNotSelected(255, 0, 0, 30);
 627                 ColorB const oObstructionNotFilled(255, 0, 0, 10);
 628                 ColorB const oNoObstructionFilled(0, 255, 0, 120);
 629                 ColorB const oNoObstructionFilledNotSelected(0, 255, 0, 30);
 630                 ColorB const oNoObstructionNotFilled(0, 255, 0, 10);
 631
 632                 COLORREF oWireColor;
 633                 if (IsSelected())
 634                         oWireColor = dc.GetSelectedColor();
 635                 else
 636                         oWireColor = GetColor();
 637
 638                 dc.SetColor(oWireColor);
 639
 640                 dc.PushMatrix(GetWorldTM());
 641
 642                 if (mv_height > 0.0f)
 643                         dc.DrawWireBox(m_box.min, m_box.max);
 644
 645                 Vec3 const v3BoxMin = m_box.min;
 646                 Vec3 const v3BoxMax = m_box.max;
 647
 648                 // Now build the 6 segments
 649                 float const fLength = v3BoxMax.x - v3BoxMin.x;
 650                 float const fWidth = v3BoxMax.y - v3BoxMin.y;
 651                 float const fHeight = v3BoxMax.z - v3BoxMin.z;
 652
 653                 Vec3 const v0(v3BoxMin);
 654                 Vec3 const v1(Vec3(v3BoxMin.x + fLength, v3BoxMin.y, v3BoxMin.z));
 655                 Vec3 const v2(Vec3(v3BoxMin.x + fLength, v3BoxMin.y + fWidth, v3BoxMin.z));
 656                 Vec3 const v3(Vec3(v3BoxMin.x, v3BoxMin.y + fWidth, v3BoxMin.z));
 657                 Vec3 const v4(Vec3(v3BoxMin.x, v3BoxMin.y, v3BoxMin.z + fHeight));
 658                 Vec3 const v5(Vec3(v3BoxMin.x + fLength, v3BoxMin.y, v3BoxMin.z + fHeight));
 659                 Vec3 const v6(Vec3(v3BoxMin.x + fLength, v3BoxMin.y + fWidth, v3BoxMin.z + fHeight));
 660                 Vec3 const v7(Vec3(v3BoxMin.x, v3BoxMin.y + fWidth, v3BoxMin.z + fHeight));
 661
 662                 // Describe the box faces
 663                 SBoxFace const aoBoxFaces[6] =
 664                 {
 665                         SBoxFace(&v0, &v4, &v5, &v1),
 666                         SBoxFace(&v1, &v5, &v6, &v2),
 667                         SBoxFace(&v2, &v6, &v7, &v3),
 668                         SBoxFace(&v3, &v7, &v4, &v0),
 669                         SBoxFace(&v4, &v5, &v6, &v7),
 670                         SBoxFace(&v0, &v1, &v2, &v3)
 671                 };
 672
 673                 // Draw each side
 674                 unsigned int const nSideCount = ((mv_height > 0.0f) ? 6 : 4);
 675                 for (unsigned int i = 0; i < nSideCount; ++i)
 676                 {
 677                         if (mv_height == 0.0f)
 678                         {
 679                                 if (IsSelected())
 680                                 {
 681                                         if (m_abObstructSound[i])
 682                                                 dc.SetColor(oObstructionFilled);
 683                                         else
 684                                                 dc.SetColor(oNoObstructionFilled);
 685                                 }
 686                                 else
 687                                         dc.SetColor(oWireColor);
 688
 689                                 dc.DrawLine(*(aoBoxFaces[i].pP1), *(aoBoxFaces[i].pP4));
 690                         }
 691
 692                         if (mv_height > 0.0f)
 693                         {
 694                                 // Manipulate the color so it looks a little thicker and redder
 695                                 if (mv_filled || gViewportPreferences.fillSelectedShapes)
 696                                 {
 697                                         ColorB const nColor = dc.GetColor();
 698
 699                                         if (m_abObstructSound[i])
 700                                                 dc.SetColor(IsSelected() ? oObstructionFilled : oObstructionFilledNotSelected);
 701                                         else
 702                                                 dc.SetColor(IsSelected() ? oNoObstructionFilled : oNoObstructionFilledNotSelected);
 703
 704                                         dc.CullOff();
 705                                         dc.DepthWriteOff();
 706
 707                                         dc.DrawQuad(*(aoBoxFaces[i].pP1), *(aoBoxFaces[i].pP2), *(aoBoxFaces[i].pP3), *(aoBoxFaces[i].pP4));
 708
 709                                         dc.DepthWriteOn();
 710                                         dc.CullOn();
 711                                         dc.SetColor(nColor);
 712                                 }
 713                                 else if (IsSelected())
 714                                 {
 715                                         ColorB const nColor = dc.GetColor();
 716
 717                                         if (m_abObstructSound[i])
 718                                                 dc.SetColor(oObstructionNotFilled);
 719                                         else
 720                                                 dc.SetColor(oNoObstructionNotFilled);
 721
 722                                         dc.CullOff();
 723                                         dc.DepthWriteOff();
 724
 725                                         dc.DrawQuad(*(aoBoxFaces[i].pP1), *(aoBoxFaces[i].pP2), *(aoBoxFaces[i].pP3), *(aoBoxFaces[i].pP4));
 726
 727                                         dc.DepthWriteOn();
 728                                         dc.CullOn();
 729                                         dc.SetColor(nColor);
 730                                 }
 731                         }
 732                 }
 733
 734                 //////////////////////////////////////////////////////////////////////////
 735                 dc.PopMatrix();
 736
 737                 DrawEntityLinks(dc);
 738                 DrawDefault(dc);
 739         }
 740 }
 741
 742 //////////////////////////////////////////////////////////////////////////
 743 void CAreaBox::InvalidateTM(int nWhyFlags)
 744 {
 745         CEntityObject::InvalidateTM(nWhyFlags);
 746 }
 747
 748 //////////////////////////////////////////////////////////////////////////
 749 void CAreaBox::Serialize(CObjectArchive& ar)
 750 {
 751         m_bIgnoreGameUpdate = 1;
 752         __super::Serialize(ar);
 753         m_bIgnoreGameUpdate = 0;
 754         CVarBlockPtr soundVarBlock = new CVarBlock;
 755
 756         XmlNodeRef xmlNode = ar.node;
 757         if (ar.bLoading)
 758         {
 759                 AABB box;
 760                 xmlNode->getAttr("BoxMin", box.min);
 761                 xmlNode->getAttr("BoxMax", box.max);
 762
 763                 SetAreaId(m_areaId);
 764                 SetBox(box);
 765         }
 766         else
 767         {
 768                 // Saving.
 769                 //              xmlNode->setAttr( "AreaId",m_areaId );
 770                 xmlNode->setAttr("BoxMin", m_box.min);
 771                 xmlNode->setAttr("BoxMax", m_box.max);
 772         }
 773
 774         if (ar.bLoading)
 775         {
 776                 for (size_t i = 0; i < ((mv_height > 0.0f) ? 6 : 4); ++i)
 777                 {
 778                         CVariable<bool>* const pvTemp = new CVariable<bool>;
 779
 780                         stack_string cTemp;
 781                         cTemp.Format("Side%d", i + 1);
 782
 783                         // And add each to the block
 784                         soundVarBlock->AddVariable(pvTemp, cTemp);
 785                 }
 786
 787                 // Now read in the data
 788                 XmlNodeRef pSoundDataNode = xmlNode->findChild("SoundData");
 789                 if (pSoundDataNode)
 790                 {
 791                         // Make sure we stay backwards compatible and also find the old "Side:" formatting
 792                         // This can go out once every level got saved with the new formatting
 793                         char const* const pcTemp = pSoundDataNode->getAttr("Side:1");
 794                         if (pcTemp && pcTemp[0])
 795                         {
 796                                 // We have the old formatting
 797                                 soundVarBlock->DeleteAllVariables();
 798
 799                                 for (size_t i = 0; i < ((mv_height > 0.0f) ? 6 : 4); ++i)
 800                                 {
 801                                         CVariable<bool>* const pvTempOld = new CVariable<bool>;
 802
 803                                         stack_string cTempOld;
 804                                         cTempOld.Format("Side:%d", i + 1);
 805
 806                                         // And add each to the block
 807                                         soundVarBlock->AddVariable(pvTempOld, cTempOld);
 808                                 }
 809                         }
 810
 811                         soundVarBlock->Serialize(pSoundDataNode, true);
 812                 }
 813
 814                 // Copy the data to the "bools" list
 815                 // First clear the remains out
 816                 m_abObstructSound.clear();
 817
 818                 unsigned int const nVarCount = soundVarBlock->GetNumVariables();
 819                 for (unsigned int i = 0; i < nVarCount; ++i)
 820                 {
 821                         IVariable const* const pTemp = soundVarBlock->GetVariable(i);
 822                         if (pTemp)
 823                         {
 824                                 bool bTemp = false;
 825                                 pTemp->Get(bTemp);
 826                                 m_abObstructSound.push_back(bTemp);
 827
 828                                 if (i >= nVarCount - 2)
 829                                 {
 830                                         // Here check for backwards compatibility reasons if "ObstructRoof" and "ObstructFloor" still exists
 831                                         bool bTemp = false;
 832                                         if (i == nVarCount - 2)
 833                                         {
 834                                                 if (xmlNode->getAttr("ObstructRoof", bTemp))
 835                                                         m_abObstructSound[i] = bTemp;
 836                                         }
 837                                         else
 838                                         {
 839                                                 if (xmlNode->getAttr("ObstructFloor", bTemp))
 840                                                         m_abObstructSound[i] = bTemp;
 841                                         }
 842                                 }
 843                         }
 844                 }
 845
 846                 // Since the var block is a static object clear it for the next object to be empty
 847                 soundVarBlock->DeleteAllVariables();
 848         }
 849         else
 850         {
 851                 XmlNodeRef pSoundDataNode = xmlNode->newChild("SoundData");
 852                 if (pSoundDataNode)
 853                 {
 854                         // TODO: What if mv_height or/and mv_width or/and mv_length == 0 ??
 855                         // For now just serialize all data
 856                         // First clear the remains out
 857                         soundVarBlock->DeleteAllVariables();
 858
 859                         // Create the variables
 860                         CRY_ASSERT(m_abObstructSound.size() == 6);
 861
 862                         size_t nIndex = 0;
 863                         tSoundObstruction::const_iterator Iter(m_abObstructSound.begin());
 864                         tSoundObstruction::const_iterator const IterEnd(m_abObstructSound.end());
 865
 866                         for (; Iter != IterEnd; ++Iter)
 867                         {
 868                                 bool const bObstructed = (bool)(*Iter);
 869
 870                                 CVariable<bool>* const pvTemp = new CVariable<bool>;
 871                                 pvTemp->Set(bObstructed);
 872                                 stack_string cTemp;
 873                                 cTemp.Format("Side%d", ++nIndex);
 874
 875                                 // And add each to the block
 876                                 soundVarBlock->AddVariable(pvTemp, cTemp);
 877                         }
 878
 879                         soundVarBlock->Serialize(pSoundDataNode, false);
 880                         soundVarBlock->DeleteAllVariables();
 881                 }
 882         }
 883 }
 884
 885 //////////////////////////////////////////////////////////////////////////
 886 XmlNodeRef CAreaBox::Export(const string& levelPath, XmlNodeRef& xmlNode)
 887 {
 888         XmlNodeRef objNode = CEntityObject::Export(levelPath, xmlNode);
 889         return objNode;
 890 }
 891
 892 //////////////////////////////////////////////////////////////////////////
 893 void CAreaBox::SetAreaId(int nAreaId)
 894 {
 895         m_areaId = nAreaId;
 896
 897         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 898         {
 899                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 900
 901                 if (pArea)
 902                 {
 903                         pArea->SetID(m_areaId);
 904                 }
 905         }
 906 }
 907
 908 //////////////////////////////////////////////////////////////////////////
 909 int CAreaBox::GetAreaId()
 910 {
 911         return m_areaId;
 912 }
 913
 914 //////////////////////////////////////////////////////////////////////////
 915 void CAreaBox::SetBox(AABB box)
 916 {
 917         m_box = box;
 918
 919         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 920         {
 921                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 922
 923                 if (pArea)
 924                 {
 925                         pArea->SetBox(m_box.min, m_box.max, nullptr, 0);
 926                 }
 927         }
 928 }
 929
 930 //////////////////////////////////////////////////////////////////////////
 931 AABB CAreaBox::GetBox()
 932 {
 933         return m_box;
 934 }
 935
 936 //////////////////////////////////////////////////////////////////////////
 937 void CAreaBox::PostLoad(CObjectArchive& ar)
 938 {
 939         __super::PostLoad(ar);
 940         UpdateGameArea();
 941         UpdateAttachedEntities();
 942 }
 943
 944 //////////////////////////////////////////////////////////////////////////
 945 bool CAreaBox::CreateGameObject()
 946 {
 947         bool const bSuccess = __super::CreateGameObject();
 948
 949         if (bSuccess)
 950         {
 951                 UpdateGameArea();
 952         }
 953
 954         return bSuccess;
 955 }
 956
 957 //////////////////////////////////////////////////////////////////////////
 958 void CAreaBox::OnEntityAdded(IEntity const* const pIEntity)
 959 {
 960         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 961         {
 962                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 963
 964                 if (pArea)
 965                 {
 966                         pArea->AddEntity(pIEntity->GetId());
 967                 }
 968         }
 969 }
 970
 971 //////////////////////////////////////////////////////////////////////////
 972 void CAreaBox::OnEntityRemoved(IEntity const* const pIEntity)
 973 {
 974         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 975         {
 976                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 977
 978                 if (pArea)
 979                 {
 980                         pArea->RemoveEntity(pIEntity->GetId());
 981                 }
 982         }
 983 }
 984
 985 //////////////////////////////////////////////////////////////////////////
 986 void CAreaBox::UpdateGameArea()
 987 {
 988         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
 989         {
 990                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
 991
 992                 if (pArea)
 993                 {
 994                         bool abObstructSound[6] = { false };
 995
 996                         size_t nIndex = 0;
 997                         tSoundObstruction::const_iterator Iter(m_abObstructSound.begin());
 998                         tSoundObstruction::const_iterator const IterEnd(m_abObstructSound.end());
 999
1000                         for (; Iter != IterEnd; ++Iter)
1001                         {
1002                                 // Here we "unpack" the data! (1 bit*nPointsCount to 1 byte*nPointsCount)
1003                                 bool const bObstructed = (bool)(*Iter);
1004                                 abObstructSound[nIndex] = bObstructed;
1005                                 ++nIndex;
1006                         }
1007
1008                         UpdateSoundPanelParams();
1009                         pArea->SetBox(m_box.min, m_box.max, &abObstructSound[0], 6);
1010                         pArea->SetProximity(m_edgeWidth);
1011                         pArea->SetID(m_areaId);
1012                         pArea->SetGroup(mv_groupId);
1013                         pArea->SetPriority(mv_priority);
1014                         pArea->SetInnerFadeDistance(m_innerFadeDistance);
1015                 }
1016         }
1017 }
1018
1019 //////////////////////////////////////////////////////////////////////////
1020 void CAreaBox::UpdateAttachedEntities()
1021 {
1022         if (m_bIgnoreGameUpdate == 0 && m_pEntity != nullptr)
1023         {
1024                 IEntityAreaComponent* pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
1025
1026                 if (pArea)
1027                 {
1028                         pArea->RemoveEntities();
1029                         size_t const numEntities = GetEntityCount();
1030
1031                         for (size_t i = 0; i < numEntities; ++i)
1032                         {
1033                                 CEntityObject* const pEntity = GetEntity(i);
1034
1035                                 if (pEntity != nullptr && pEntity->GetIEntity() != nullptr)
1036                                 {
1037                                         pArea->AddEntity(pEntity->GetIEntity()->GetId());
1038                                 }
1039                         }
1040                 }
1041         }
1042 }
1043
1044 //////////////////////////////////////////////////////////////////////////
1045 void CAreaBox::OnSoundParamsChange(IVariable* var)
1046 {
1047         if (!m_bIgnoreGameUpdate && mv_displaySoundInfo)
1048         {
1049                 // Refresh inspector
1050                 UpdateUIVars();
1051         }
1052 }
1053
1054 //////////////////////////////////////////////////////////////////////////
1055 void CAreaBox::OnPointChange(IVariable* var)
1056 {
1057         CRY_ASSERT(m_abObstructSound.size() == 6);
1058         size_t const numVariables = static_cast<size_t>(m_pOwnSoundVarBlock->GetNumVariables());
1059
1060         for (size_t i = 0; i < numVariables; ++i)
1061         {
1062                 if (m_pOwnSoundVarBlock->GetVariable(i) == var)
1063                 {
1064                         if (m_pEntity != nullptr)
1065                         {
1066                                 IEntityAreaComponent* const pArea = m_pEntity->GetOrCreateComponent<IEntityAreaComponent>();
1067
1068                                 if (pArea)
1069                                 {
1070                                         bool bValue = false;
1071                                         var->Get(bValue);
1072                                         pArea->SetSoundObstructionOnAreaFace(i, bValue);
1073                                         m_abObstructSound[i] = bValue;
1074                                 }
1075                         }
1076
1077                         break;
1078                 }
1079         }
1080 }
1081
1082 //////////////////////////////////////////////////////////////////////////
1083 void CAreaBox::UpdateSoundPanelParams()
1084 {
1085         if (!m_bIgnoreGameUpdate && mv_displaySoundInfo)
1086         {
1087                 UpdateUIVars();
1088         }
1089 }