Code/Sandbox/Plugins/CryDesigner/Objects/DesignerObject.cpp

   1 // Copyright 2001-2019 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "DesignerObject.h"
   5
   6 #include "Util/Converter.h"
   7 #include "Util/Display.h"
   8 #include "Util/PrimitiveShape.h"
   9 #include "Util/Undo.h"
  10 #include "DesignerEditor.h"
  11
  12 #include <IAIManager.h>
  13 #include <Material/MaterialManager.h>
  14 #include <GameEngine.h>
  15
  16 #include <Controls/DynamicPopupMenu.h>
  17 #include <Objects/ObjectLoader.h>
  18 #include <Objects/InspectorWidgetCreator.h>
  19 #include <Preferences/ViewportPreferences.h>
  20 #include <Serialization/Decorators/EditorActionButton.h>
  21
  22 #include <CryCore/Base64.h>
  23
  24 namespace Designer
  25 {
  26 IMPLEMENT_DYNCREATE(DesignerObject, CBaseObject)
  27
  28 REGISTER_CLASS_DESC(BoxObjectClassDesc)
  29 REGISTER_CLASS_DESC(SphereObjectClassDesc)
  30 REGISTER_CLASS_DESC(ConeObjectClassDesc)
  31 REGISTER_CLASS_DESC(CylinderObjectClassDesc)
  32
  33 REGISTER_CLASS_DESC(DesignerObjectClassDesc)
  34
  35 REGISTER_CLASS_DESC(SolidObjectClassDesc)
  36
  37 DesignerObject::DesignerObject()
  38 {
  39         m_pCompiler = new ModelCompiler(eCompiler_General);
  40         m_nBrushUniqFileId = s_nGlobalBrushDesignerFileId;
  41         m_EngineFlags.m_pObj = this;
  42         ++s_nGlobalBrushDesignerFileId;
  43         m_bSupportsBoxHighlight = false;
  44 }
  45
  46 void GeneratePrimitiveShape(PolygonList& polygonList, string primitiveType)
  47 {
  48         PrimitiveShape bp;
  49
  50         BrushVec3 min(0.0, 0.0, 0.0);
  51         BrushVec3 max(1.0, 1.0, 1.0);
  52
  53         if (primitiveType == "DesignerSphere")
  54         {
  55                 min -= BrushVec3(0.0, 0.0, 0.5);
  56                 max -= BrushVec3(0.0, 0.0, 0.5);
  57
  58                 bp.CreateSphere(
  59                         min,
  60                         max,
  61                         16,
  62                         &polygonList);
  63         }
  64         else if (primitiveType == "DesignerBox")
  65         {
  66                 bp.CreateBox(
  67                         min,
  68                         max,
  69                         &polygonList);
  70         }
  71         else if (primitiveType == "DesignerCylinder")
  72         {
  73                 bp.CreateCylinder(
  74                         min,
  75                         max,
  76                         16,
  77                         &polygonList);
  78         }
  79         else if (primitiveType == "DesignerCone")
  80         {
  81                 bp.CreateCone(
  82                         min,
  83                         max,
  84                         16,
  85                         &polygonList);
  86         }
  87 }
  88
  89 bool DesignerObject::Init(CBaseObject* prev, const string& file)
  90 {
  91         SetMaterial(BrushDesignerDefaultMaterial);
  92
  93         if (prev)
  94         {
  95                 DesignerObject* pGeomObj = static_cast<DesignerObject*>(prev);
  96
  97                 Model* pModel = pGeomObj->GetModel();
  98                 if (pModel)
  99                 {
 100                         Model* pClonedModel = new Model(*pModel);
 101                         SetModel(pClonedModel);
 102                 }
 103
 104                 ModelCompiler* pFrontBrush = pGeomObj->GetCompiler();
 105                 if (pFrontBrush)
 106                 {
 107                         ModelCompiler* pClonedCompilier = new ModelCompiler(*pFrontBrush);
 108                         SetCompiler(pClonedCompilier);
 109                         ApplyPostProcess(GetMainContext(), ePostProcess_Mesh);
 110                 }
 111         }
 112
 113         bool ret = CBaseObject::Init(prev, file);
 114
 115         // Finished initialization, now generate geometry for this object type.
 116         // Do this only for new objects, or we risk duplicating lots of cubes
 117         if (ret && !prev && (!file.IsEmpty()))
 118         {
 119                 PolygonList polygonList;
 120
 121                 polygonList.clear();
 122
 123                 GeneratePrimitiveShape(polygonList, file);
 124
 125                 MODEL_SHELF_RECONSTRUCTOR(GetModel());
 126
 127                 GetModel()->SetShelf(eShelf_Base);
 128                 GetModel()->Clear();
 129                 for (int i = 0, iPolygonCount(polygonList.size()); i < iPolygonCount; ++i)
 130                 {
 131                         polygonList[i]->SetSubMatID(0);
 132                         GetModel()->AddUnionPolygon(polygonList[i]);
 133                 }
 134
 135                 ApplyPostProcess(GetMainContext(), ePostProcess_Mesh);
 136         }
 137
 138         return ret;
 139 }
 140
 141 void DesignerObject::Display(CObjectRenderHelper& objRenderHelper)
 142 {
 143         SDisplayContext& dc = objRenderHelper.GetDisplayContextRef();
 144
 145         if (dc.display2D)
 146         {
 147                 dc.PushMatrix(GetWorldTM());
 148                 Display::DisplayModel(dc, GetModel(), NULL, eShelf_Any, 2, IsSelected() ? kSelectedColor : ColorB(0, 0, 0));
 149                 dc.PopMatrix();
 150         }
 151         else
 152         {
 153                 DrawDefault(dc);
 154                 DrawOpenPolygons(dc);
 155         }
 156 }
 157
 158 const ColorB& DesignerObject::GetSelectionPreviewHighlightColor()
 159 {
 160         return gViewportSelectionPreferences.solidBrushGeometryColor;
 161 }
 162
 163 void DesignerObject::DrawOpenPolygons(SDisplayContext& dc)
 164 {
 165         dc.PushMatrix(GetWorldTM());
 166
 167         ColorB oldColor = dc.GetColor();
 168         int oldLineWidth = dc.GetLineWidth();
 169
 170         dc.SetColor(ColorB(0, 0, 2));
 171         dc.SetLineWidth(2);
 172         for (int i = 0, iPolygonCount(GetModel()->GetPolygonCount()); i < iPolygonCount; ++i)
 173         {
 174                 PolygonPtr pPolygon = GetModel()->GetPolygon(i);
 175                 if (!pPolygon->IsOpen())
 176                         continue;
 177                 Display::DisplayPolygon(dc, pPolygon);
 178         }
 179         dc.SetColor(oldColor);
 180         dc.SetLineWidth(oldLineWidth);
 181
 182         dc.PopMatrix();
 183 }
 184
 185 void DesignerObject::GetBoundBox(AABB& box)
 186 {
 187         if (GetModel())
 188         {
 189                 for (int i = eShelf_Base; i < cShelfMax; ++i)
 190                 {
 191                         if (!GetModel()->IsEmpty(static_cast<ShelfID>(i)))
 192                         {
 193                                 box.SetTransformedAABB(GetWorldTM(), GetModel()->GetBoundBox(static_cast<ShelfID>(i)));
 194                                 return;
 195                         }
 196                 }
 197         }
 198
 199         BrushVec3 vWorldPos = GetWorldTM().GetTranslation();
 200         box = AABB(vWorldPos, vWorldPos);
 201 }
 202
 203 void DesignerObject::GetLocalBounds(AABB& box)
 204 {
 205         if (GetModel())
 206         {
 207                 box = GetModel()->GetBoundBox(eShelf_Base);
 208         }
 209         else
 210         {
 211                 box = AABB(Vec3(0, 0, 0), Vec3(0, 0, 0));
 212         }
 213 }
 214
 215 bool DesignerObject::HitTest(HitContext& hc)
 216 {
 217         BrushRay ray;
 218         GetLocalViewRay(GetWorldTM(), hc.view, hc.point2d, ray);
 219
 220         if (Designer::HitTest(ray, GetMainContext(), hc))
 221         {
 222                 hc.object = this;
 223                 return true;
 224         }
 225         else if (GetModel())
 226         {
 227                 BrushMatrix34 invMat = GetWorldTM().GetInverted();
 228                 for (int i = 0, iPolygonCount(GetModel()->GetPolygonCount()); i < iPolygonCount; ++i)
 229                 {
 230                         PolygonPtr pPolygon = GetModel()->GetPolygon(i);
 231                         if (!pPolygon->IsOpen())
 232                                 continue;
 233                         for (int k = 0, iEdgeCount(pPolygon->GetEdgeCount()); k < iEdgeCount; ++k)
 234                         {
 235                                 BrushEdge3D edge = pPolygon->GetEdge(k);
 236                                 if (HitTestEdge(ray, pPolygon->GetPlane().Normal(), edge, hc.view))
 237                                 {
 238                                         hc.object = this;
 239                                         return true;
 240                                 }
 241                         }
 242                 }
 243         }
 244         return false;
 245 }
 246
 247 IPhysicalEntity* DesignerObject::GetCollisionEntity() const
 248 {
 249         if (GetCompiler() == NULL)
 250                 return NULL;
 251         if (GetCompiler()->GetRenderNode())
 252                 return GetCompiler()->GetRenderNode()->GetPhysics();
 253         return NULL;
 254 }
 255
 256 void DesignerObject::OnContextMenu(CPopupMenuItem* menu)
 257 {
 258         // Add button to enter edit mode
 259         menu->Add("Edit", [=]()
 260                 {
 261                         BeginUndoAndEnsureSelection();
 262                         GetIEditor()->GetIUndoManager()->Accept("Select Object");
 263                         GetIEditor()->ExecuteCommand("general.open_pane 'Modeling'");
 264                 });
 265         // then show the rest of object properties
 266         CBaseObject::OnContextMenu(menu);
 267 }
 268
 269 void DesignerObject::Serialize(CObjectArchive& ar)
 270 {
 271         CBaseObject::Serialize(ar);
 272
 273         XmlNodeRef xmlNode = ar.node;
 274
 275         if (ar.bLoading)
 276         {
 277                 string typeName("Designer");
 278                 xmlNode->getAttr("Type", typeName);
 279
 280                 bool bDesignerBinary = false;
 281                 xmlNode->getAttr("DesignerBinary", bDesignerBinary);
 282
 283                 XmlNodeRef brushNode = xmlNode->findChild("Brush");
 284                 if (brushNode)
 285                 {
 286                         bool bDesignerObject = true;
 287                         if (!brushNode->haveAttr("DesignerModeFlags"))
 288                                 bDesignerObject = false;
 289
 290                         if (!GetCompiler())
 291                                 SetCompiler(new ModelCompiler(eCompiler_General));
 292
 293                         if (!GetModel())
 294                                 SetModel(new Model);
 295
 296                         if (bDesignerObject)
 297                         {
 298                                 if (ar.bUndo || !bDesignerBinary)
 299                                         GetModel()->Serialize(brushNode, ar.bLoading, ar.bUndo);
 300                         }
 301                         else
 302                         {
 303                                 bool bConvertSuccess = Converter::ConvertSolidXMLToDesignerObject(brushNode, this);
 304                                 CRY_ASSERT(bConvertSuccess);
 305                         }
 306                 }
 307
 308                 if (ar.bUndo)
 309                 {
 310                         if (GetCompiler())
 311                                 GetCompiler()->DeleteAllRenderNodes();
 312                 }
 313
 314                 if (GetCompiler())
 315                 {
 316                         uint64 nRenderFlag = ERF_HAS_CASTSHADOWMAPS | ERF_CASTSHADOWMAPS;
 317                         ar.node->getAttr("RndFlags", nRenderFlag, false);
 318                         if (nRenderFlag & ERF_CASTSHADOWMAPS)
 319                                 nRenderFlag |= ERF_HAS_CASTSHADOWMAPS;
 320                         GetCompiler()->SetRenderFlags(nRenderFlag);
 321                         int nStatObjFlag = 0;
 322                         if (ar.node->getAttr("StaticObjFlags", nStatObjFlag))
 323                                 GetCompiler()->SetStaticObjFlags(nStatObjFlag);
 324                         int nViewDistRadio = kDefaultViewDist;
 325                         ar.node->getAttr("ViewDistRatio", nViewDistRadio);
 326                         GetCompiler()->SetViewDistRatio(nViewDistRadio);
 327
 328                         XmlNodeRef meshNode = ar.node->findChild("Mesh");
 329                         if (meshNode)
 330                         {
 331                                 const char* encodedStr;
 332                                 int nVersion = 0;
 333                                 meshNode->getAttr("Version", nVersion);
 334                                 if (meshNode->getAttr("BinaryData", &encodedStr))
 335                                 {
 336                                         int nLength = strlen(encodedStr);
 337                                         if (nLength > 0)
 338                                         {
 339                                                 int nDestBufferLen = Base64::decodedsize_base64(nLength);
 340                                                 std::vector<char> buffer;
 341                                                 buffer.resize(nDestBufferLen, 0);
 342                                                 Base64::decode_base64(&buffer[0], encodedStr, nLength, false);
 343                                                 GetCompiler()->LoadMesh(nVersion, buffer, this, GetModel());
 344                                                 bDesignerBinary = true;
 345                                         }
 346                                 }
 347                         }
 348
 349                         m_EngineFlags.Set();
 350                 }
 351
 352                 if (ar.bUndo || !bDesignerBinary)
 353                 {
 354                         if (GetModel()->GetSubdivisionLevel() > 0)
 355                                 GetModel()->ResetDB(eDBRF_Vertex);
 356                         ApplyPostProcess(GetMainContext(), ePostProcess_Mesh);
 357                 }
 358         }
 359         else
 360         {
 361                 if (GetModel())
 362                 {
 363                         XmlNodeRef brushNode = xmlNode->newChild("Brush");
 364                         GetModel()->Serialize(brushNode, ar.bLoading, ar.bUndo);
 365                 }
 366                 if (m_pCompiler)
 367                 {
 368                         ar.node->setAttr("RndFlags", ERF_GET_WRITABLE(GetCompiler()->GetRenderFlags()), false);
 369                         ar.node->setAttr("StaticObjFlags", ERF_GET_WRITABLE(GetCompiler()->GetStaticObjFlags()));
 370                         ar.node->setAttr("ViewDistRatio", GetCompiler()->GetViewDistRatio());
 371                         if (!GetCompiler()->IsValid())
 372                                 GetCompiler()->Compile(this, GetModel());
 373
 374                         if (GetCompiler()->IsValid() && !ar.bUndo)
 375                         {
 376                                 XmlNodeRef meshNode = xmlNode->newChild("Mesh");
 377                                 std::vector<char> meshBuffer;
 378                                 const int nMeshVersion = 2;
 379                                 if (GetCompiler()->SaveMesh(nMeshVersion, meshBuffer, this, GetModel()))
 380                                 {
 381                                         unsigned int meshBufferSize = meshBuffer.size();
 382                                         std::vector<char> encodedStr(Base64::encodedsize_base64(meshBufferSize) + 1);
 383                                         Base64::encode_base64(&encodedStr[0], &meshBuffer[0], meshBufferSize, true);
 384                                         meshNode->setAttr("Version", nMeshVersion);
 385                                         meshNode->setAttr("BinaryData", &encodedStr[0]);
 386                                 }
 387                         }
 388                 }
 389         }
 390 }
 391
 392 // Get a list of incompatible subtools with current Designer Object type
 393 std::vector<EDesignerTool> DesignerObject::GetIncompatibleSubtools()
 394 {
 395         return std::vector<EDesignerTool>();
 396 }
 397
 398 void DesignerObject::CreateInspectorWidgets(CInspectorWidgetCreator& creator)
 399 {
 400         CBaseObject::CreateInspectorWidgets(creator);
 401
 402         creator.AddPropertyTree<DesignerObject>("Designer", [](DesignerObject* pObject, Serialization::IArchive& ar, bool bMultiEdit)
 403                 {
 404                         pObject->m_EngineFlags.Serialize(ar);
 405
 406                         if (ar.openBlock("Edit", "<Edit"))
 407                         {
 408                           ar(Serialization::ActionButton([=]
 409                                 {
 410                                         GetIEditor()->ExecuteCommand("general.open_pane 'Modeling'");
 411                                 })
 412                              , "edit", "^Edit");
 413                           ar.closeBlock();
 414                         }
 415
 416                         if (ar.isInput())
 417                         {
 418                           pObject->UpdateGameResource();
 419                         }
 420                 });
 421 }
 422
 423 void DesignerObject::SetMaterial(IEditorMaterial* mtl)
 424 {
 425         bool bAssignedSubmaterial = false;
 426
 427         if (mtl == NULL)
 428                 mtl = GetIEditor()->GetMaterialManager()->LoadMaterial(BrushDesignerDefaultMaterial);
 429
 430         CMaterial* pParentMat = mtl ? ((CMaterial*)mtl)->GetParent() : NULL;
 431         if (pParentMat && pParentMat == GetMaterial())
 432         {
 433                 DesignerSession* pSession = DesignerSession::GetInstance();
 434                 Model* pModel = GetModel();
 435
 436                 for (int i = 0, iSubMatCount(pParentMat->GetSubMaterialCount()); i < iSubMatCount; ++i)
 437                 {
 438                         if (pParentMat->GetSubMaterial(i) != mtl)
 439                                 continue;
 440
 441                         if (pSession->GetIsActive())
 442                         {
 443                                 CBaseObject* pObject = pSession->GetBaseObject();
 444
 445                                 if (CUndo::IsRecording() && pObject)
 446                                         CUndo::Record(new UndoTextureMapping(pObject, "Designer : SetSubMatID"));
 447
 448                                 ElementSet* pSelected = pSession->GetSelectedElements();
 449                                 if (pSelected->IsEmpty())
 450                                         pModel->SetSubMatID(i);
 451                                 else
 452                                         AssignMatIDToSelectedPolygons(i);
 453
 454                                 pSession->SetCurrentSubMatID(i);
 455                         }
 456                         else
 457                                 pModel->SetSubMatID(i);
 458
 459                         GetCompiler()->Compile(this, GetModel());
 460                         bAssignedSubmaterial = true;
 461                         break;
 462                 }
 463         }
 464
 465         if (!bAssignedSubmaterial)
 466         {
 467                 if (!pParentMat)
 468                 {
 469                         CBaseObject::SetMaterial(mtl);
 470                 }
 471                 else if (pParentMat != GetMaterial())
 472                 {
 473                         CBaseObject::SetMaterial(pParentMat);
 474                         SetMaterial(mtl);
 475                 }
 476         }
 477
 478         UpdateEngineNode();
 479 }
 480
 481 void DesignerObject::SetMaterial(const string& materialName)
 482 {
 483         CMaterial* pMaterial = NULL;
 484         pMaterial = GetIEditor()->GetMaterialManager()->LoadMaterial(materialName);
 485         if (!pMaterial || (pMaterial && pMaterial->IsDummy()))
 486         {
 487                 IMaterial* pMatInfo = GetIEditor()->Get3DEngine()->GetMaterialManager()->LoadMaterial(materialName, false);
 488                 if (pMatInfo)
 489                 {
 490                         GetIEditor()->GetMaterialManager()->OnCreateMaterial(pMatInfo);
 491                         pMaterial = GetIEditor()->GetMaterialManager()->FromIMaterial(pMatInfo);
 492                 }
 493         }
 494         CBaseObject::SetMaterial(pMaterial);
 495
 496         const string materialNameWithoutExtension = PathUtil::RemoveExtension(materialName);
 497         if (pMaterial->GetName() != materialNameWithoutExtension)
 498                 m_materialNameOverride = materialNameWithoutExtension;
 499         else
 500                 m_materialNameOverride.Empty();
 501
 502         UpdateEngineNode();
 503 }
 504
 505 void DesignerObject::SetSelected(bool bSelect)
 506 {
 507         CBaseObject::SetSelected(bSelect);
 508         GetCompiler()->SetSelected(bSelect);
 509 }
 510
 511 string DesignerObject::GetMaterialName() const
 512 {
 513         if (!m_materialNameOverride.IsEmpty())
 514                 return m_materialNameOverride;
 515
 516         return CBaseObject::GetMaterialName();
 517 }
 518
 519 void DesignerObject::SetMaterialLayersMask(uint32 nLayersMask)
 520 {
 521         CBaseObject::SetMaterialLayersMask(nLayersMask);
 522         UpdateEngineNode();
 523 }
 524
 525 void DesignerObject::SetMinSpec(uint32 nSpec, bool bSetChildren)
 526 {
 527         __super::SetMinSpec(nSpec, bSetChildren);
 528         if (GetCompiler() && GetCompiler()->GetRenderNode())
 529                 GetCompiler()->GetRenderNode()->SetMinSpec(GetMinSpec());
 530 }
 531
 532 bool DesignerObject::IsSimilarObject(CBaseObject* pObject) const
 533 {
 534         if (pObject->GetClassDesc() == GetClassDesc() && GetRuntimeClass() == pObject->GetRuntimeClass())
 535                 return true;
 536         return false;
 537 }
 538
 539 void DesignerObject::OnEvent(ObjectEvent event)
 540 {
 541         CBaseObject::OnEvent(event);
 542         switch (event)
 543         {
 544         case EVENT_INGAME:
 545                 {
 546                         if (CheckFlags(OBJFLAG_SUBOBJ_EDITING))
 547                                 EndSubObjectSelection();
 548                         DesignerEditor* pDesignerTool = GetDesigner();
 549                         if (pDesignerTool && !GetIEditor()->GetGameEngine()->GetSimulationMode())
 550                                 pDesignerTool->LeaveCurrentTool();
 551                 }
 552                 break;
 553         case EVENT_OUTOFGAME:
 554                 {
 555                         DesignerEditor* pDesignerTool = GetDesigner();
 556                         if (pDesignerTool)
 557                                 pDesignerTool->EnterCurrentTool();
 558                 }
 559                 break;
 560         }
 561 }
 562
 563 void DesignerObject::WorldToLocalRay(Vec3& raySrc, Vec3& rayDir) const
 564 {
 565         raySrc = m_invertTM.TransformPoint(raySrc);
 566         rayDir = m_invertTM.TransformVector(rayDir).GetNormalized();
 567 }
 568
 569 void DesignerObject::InvalidateTM(int nWhyFlags)
 570 {
 571         CBaseObject::InvalidateTM(nWhyFlags);
 572         UpdateEngineNode();
 573         m_invertTM = GetWorldTM();
 574         m_invertTM.Invert();
 575 }
 576
 577 void DesignerObject::GenerateGameFilename(string& generatedFileName) const
 578 {
 579         generatedFileName.Format("%%level%%/Brush/designer_%d.%s", m_nBrushUniqFileId, CRY_GEOMETRY_FILE_EXT);
 580 }
 581
 582 void DesignerObject::DrawDimensions(SDisplayContext& dc, AABB* pMergedBoundBox)
 583 {
 584         if (!HasMeasurementAxis() || GetDesigner() || !gDesignerSettings.bDisplayDimensionHelper)
 585                 return;
 586         AABB localBoundBox;
 587         GetLocalBounds(localBoundBox);
 588         DrawDimensionsImpl(dc, localBoundBox, pMergedBoundBox);
 589 }
 590
 591 IRenderNode* DesignerObject::GetEngineNode() const
 592 {
 593         if (!GetCompiler() || !GetCompiler()->GetRenderNode())
 594                 return NULL;
 595         return GetCompiler()->GetRenderNode();
 596 }
 597
 598 DesignerObjectFlags::DesignerObjectFlags() : m_pObj(NULL)
 599 {
 600         outdoor = false;
 601         castShadows = true;
 602         giMode = true;
 603         supportSecVisArea = false;
 604         rainOccluder = false;
 605         hideable = false;
 606         ratioViewDist = 100;
 607         excludeFromTriangulation = false;
 608         noDynWater = false;
 609         noStaticDecals = false;
 610         excludeCollision = false;
 611         occluder = false;
 612         ignoreTerrainLayerBlend = false;
 613         ignoreDecalBlend = false;
 614 }
 615
 616 void DesignerObjectFlags::Set()
 617 {
 618         ratioViewDist = m_pObj->GetCompiler()->GetViewDistRatio();
 619         uint64 flags = m_pObj->GetCompiler()->GetRenderFlags();
 620         int statobjFlags = m_pObj->GetCompiler()->GetStaticObjFlags();
 621         outdoor = (flags & ERF_OUTDOORONLY) != 0;
 622         rainOccluder = (flags & ERF_RAIN_OCCLUDER) != 0;
 623         castShadows = (flags & ERF_CASTSHADOWMAPS) != 0;
 624         giMode = (flags & ERF_GI_MODE_BIT0) != 0;
 625         supportSecVisArea = (flags & ERF_REGISTER_BY_BBOX) != 0;
 626         occluder = (flags & ERF_GOOD_OCCLUDER) != 0;
 627         hideable = (flags & ERF_HIDABLE) != 0;
 628         noDynWater = (flags & ERF_NODYNWATER) != 0;
 629         noStaticDecals = (flags & ERF_NO_DECALNODE_DECALS) != 0;
 630         excludeFromTriangulation = (flags & ERF_EXCLUDE_FROM_TRIANGULATION) != 0;
 631         excludeCollision = (statobjFlags & STATIC_OBJECT_NO_PLAYER_COLLIDE) != 0;
 632         ignoreTerrainLayerBlend = (flags & ERF_FOB_ALLOW_TERRAIN_LAYER_BLEND) == 0;
 633         ignoreDecalBlend = (flags & ERF_FOB_ALLOW_DECAL_BLEND) == 0;
 634 }
 635
 636 void DesignerObjectFlags::Serialize(Serialization::IArchive& ar)
 637 {
 638         ar(castShadows, "castShadows", "Cast Shadows");
 639         ar(giMode, "globalIllumination", "Global Illumination");
 640         ar(supportSecVisArea, "supportSecVisArea", "Support Second Visarea");
 641         ar(outdoor, "outdoor", "Outdoor");
 642         ar(rainOccluder, "rainOccluder", "Rain Occluder");
 643         ar(ratioViewDist, "ratioViewDist", "View Distance Ratio");
 644         ar(excludeFromTriangulation, "excludeFromTriangulation", "Exclude From Navigation");
 645         ar(hideable, "hideable", "AI Hideable");
 646         ar(noDynWater, "noDynWater", "No Dynamic Water");
 647         ar(noStaticDecals, "noStaticDecals", "No Static Decal");
 648         ar(excludeCollision, "excludeCollision", "Exclude Collision");
 649         ar(occluder, "occluder", "Occluder");
 650         ar(ignoreTerrainLayerBlend, "ignoreTerrainLayerBlend", "Ignore Terrain Layer Blending");
 651         ar(ignoreDecalBlend, "ignoreDecalBlend", "Ignore Decal Blending");
 652         if (ar.isInput())
 653                 Update();
 654 }
 655
 656 template<typename T>
 657 void ModifyFlag(T& nFlags, const T& flag, const T& clearFlag, bool var)
 658 {
 659         nFlags = (var) ? (nFlags | flag) : (nFlags & (~clearFlag));
 660 }
 661 template<typename T>
 662 void ModifyFlag(T& nFlags, const T& flag, bool var)
 663 {
 664         ModifyFlag(nFlags, flag, flag, var);
 665 }
 666
 667 void DesignerObjectFlags::Update()
 668 {
 669         const uint64 nOldFlags = m_pObj->GetCompiler()->GetRenderFlags();
 670         uint64 nFlags = nOldFlags;
 671         int statobjFlags = m_pObj->GetCompiler()->GetStaticObjFlags();
 672
 673         ModifyFlag<uint64>(nFlags, ERF_OUTDOORONLY, outdoor);
 674         ModifyFlag<uint64>(nFlags, ERF_RAIN_OCCLUDER, rainOccluder);
 675         ModifyFlag<uint64>(nFlags, ERF_CASTSHADOWMAPS | ERF_HAS_CASTSHADOWMAPS, ERF_CASTSHADOWMAPS, castShadows);
 676         ModifyFlag<uint64>(nFlags, ERF_GI_MODE_BIT0, giMode);
 677         ModifyFlag<uint64>(nFlags, ERF_REGISTER_BY_BBOX, supportSecVisArea);
 678         ModifyFlag<uint64>(nFlags, ERF_HIDABLE, hideable);
 679         ModifyFlag<uint64>(nFlags, ERF_EXCLUDE_FROM_TRIANGULATION, excludeFromTriangulation);
 680         ModifyFlag<uint64>(nFlags, ERF_NODYNWATER, noDynWater);
 681         ModifyFlag<uint64>(nFlags, ERF_NO_DECALNODE_DECALS, noStaticDecals);
 682         ModifyFlag<uint64>(nFlags, ERF_GOOD_OCCLUDER, occluder);
 683         ModifyFlag<uint64>(nFlags, ERF_FOB_ALLOW_TERRAIN_LAYER_BLEND, !ignoreTerrainLayerBlend);
 684         ModifyFlag<uint64>(nFlags, ERF_FOB_ALLOW_DECAL_BLEND, !ignoreDecalBlend);
 685         ModifyFlag<int>(statobjFlags, STATIC_OBJECT_NO_PLAYER_COLLIDE, excludeCollision);
 686
 687         m_pObj->GetCompiler()->SetViewDistRatio(ratioViewDist);
 688         m_pObj->GetCompiler()->SetRenderFlags(nFlags);
 689         m_pObj->GetCompiler()->SetStaticObjFlags(statobjFlags);
 690         m_pObj->GetCompiler()->Compile(m_pObj, m_pObj->GetModel(), eShelf_Base, true);
 691         ApplyPostProcess(m_pObj->GetMainContext(), ePostProcess_SyncPrefab);
 692
 693         if ((nOldFlags & ERF_EXCLUDE_FROM_TRIANGULATION) != (nFlags & ERF_EXCLUDE_FROM_TRIANGULATION))
 694         {
 695                 AABB bbox;
 696                 m_pObj->GetBoundBox(bbox);
 697                 GetIEditor()->GetAIManager()->OnAreaModified(bbox);
 698         }
 699 }
 700
 701 }